Amazon GameLiftManuel du développeur

Version

Amazon GameLift Manuel du développeur

Amazon GameLift: Manuel du développeurCopyright © 2020 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 manner that is likely to cause confusion among customers, or in any manner that disparages or discreditsAmazon. All other trademarks not owned by Amazon are the property of their respective owners, who may or may notbe affiliated with, connected to, or sponsored by Amazon.

Amazon GameLift Manuel du développeur

Table of ContentsPrésentation d'Amazon GameLift? ......................................................................................................... 1

Pourquoi choisir GameLift ? ......................................................................................................... 1GameLift solutions ...................................................................................................................... 1

GameLift hébergement ........................................................................................................ 1GameLift hébergement avec Serveurs en temps réel ............................................................... 2GameLift FleetIQ pour l’hébergement Amazon EC2 ................................................................. 3

Fonctionnement d'un GameLift ..................................................................................................... 3Composants clés ................................................................................................................ 3Hébergement de serveurs de jeux ........................................................................................ 4Exécution des sessions de jeu ............................................................................................. 5Dimensionnement de la capacité d'une flotte .......................................................................... 6Supervision de l'activité de la flotte et dépannage .................................................................... 8Mise en réseau avec les ressources AWS .............................................................................. 9

Fonctionnement des Serveurs en temps réel .................................................................................. 9Que sont les serveurs en temps réel ? .................................................................................. 9Choix de Serveurs en temps réel pour votre jeu .................................................................... 10Composants clés .............................................................................................................. 10Comment Serveurs en temps réel gère les sessions de jeu ..................................................... 11L'interaction entre les clients et serveurs en temps réel ........................................................... 11Personnalisation d'un serveur RealTime ............................................................................... 12Déployer et mettre à jour les Serveurs en temps réel ............................................................. 13

Comment les joueurs se connectent aux Jeux ............................................................................... 13Fonctionnalités d'une session de joueur et d'une session de jeu ............................................... 13

Fonctionnement d'GameLift FlexMatch ......................................................................................... 15Fonctionnalités principales de FlexMatch .............................................................................. 15Composants de FlexMatch ................................................................................................. 16Processus de mise en relation ............................................................................................ 16Processus de remplissage .................................................................................................. 18

Architecture de jeu avec solution GameLift gérée .......................................................................... 19Architecture de jeu avec Serveurs en temps réel ........................................................................... 21

Configuration .................................................................................................................................... 23Configuration d'un compte AWS .................................................................................................. 23

Exemples de stratégie IAM ................................................................................................. 24Configuration d'un rôle pour lGameLift'accès ................................................................................. 26GameLift SDKs ......................................................................................................................... 27

Pour les serveurs de jeux personnalisés .............................................................................. 27Pour Serveurs en temps réel .............................................................................................. 28Pour les services à la clientèle ........................................................................................... 28

Outils et ressources .................................................................................................................. 29Outils principaux ............................................................................................................... 29Ressources supplémentaires .............................................................................................. 30

Configuration des alertes de facturation AWS ................................................................................ 30Utilisation d'GameLift dans les régions AWS ................................................................................. 31

Démarrez ......................................................................................................................................... 32Exploration d'GameLift ............................................................................................................... 32

Exemple de jeu Serveurs en temps réel (source complète) ...................................................... 32Exemple de serveur de jeu personnalisé (Experience de console) ............................................ 33

Premiers pas avec les serveurs personnalisés .............................................................................. 33Premiers pas avec Serveurs en temps réel ................................................................................... 35

Préparation de jeux pour GameLift ...................................................................................................... 37Intégration de jeux avec des serveurs de jeu personnalisés ............................................................. 37

Moteurs de jeux et GameLift .............................................................................................. 37Intégration d’un serveur de jeux .......................................................................................... 45Intégration d'un client de jeu ............................................................................................... 52

Versioniii

Amazon GameLift Manuel du développeur

GameLift les interactions .................................................................................................... 58Test de l'intégration ........................................................................................................... 61

Intégration de jeux avec Serveurs en temps réel ........................................................................... 66Intégration d'un client de jeu ............................................................................................... 67Personnalisation d'un script RealTime .................................................................................. 71

Ajout en cours de mise en relation FlexMatch ............................................................................... 77feuille FlexMatch de route de l'intégration d' .......................................................................... 78Ajouter FlexMatch à un client de jeu .................................................................................... 79Ajouter FlexMatch à un serveur de jeux ............................................................................... 83Renvoi des jeux existants .................................................................................................. 85

Gestion des ressources d'hébergement ................................................................................................ 92À propos des ressources d'hébergement GameLift ......................................................................... 92.............................................................................................................................................. 94

Bonnes pratiques .............................................................................................................. 94Utilisation de piles AWS CloudFormation .............................................................................. 95Mise à jour des builds ....................................................................................................... 99

Chargement des builds et scripts ............................................................................................... 101Télécharger une build de serveur personnalisée .................................................................. 101Chargement d'un Serveurs en temps réel script ................................................................... 107

Configuration de flottes ............................................................................................................ 110Guide de conception de flotte ........................................................................................... 110Déployer une flotte pour une build de jeu personnalisée ........................................................ 116Déployer une flotte Serveurs en temps réel ......................................................................... 120Gestion de vos flottes ...................................................................................................... 124Ajouter un alias à une flotte .............................................................................................. 126Déboguer les incidents de flotte ........................................................................................ 127Accès à distance aux instances de flotte ............................................................................ 130

Dimensionnement de la capacité d'une flotte ............................................................................... 133Pour définir la capacité de la flotte dans la console .............................................................. 133Définir les limites de capacité d'une flotte ........................................................................... 134Définir manuellement la capacité de la flotte ........................................................................ 135Dimensionnement automatique de la capacité d'une flotte ..................................................... 137

Utilisation de files d'attente sur plusieurs régions .......................................................................... 143Conception d'une file d'attente .......................................................................................... 143Création d'une file d'attente .............................................................................................. 149Afficher vos files d'attente ................................................................................................. 152

Configuration de matchmakers FlexMatch ................................................................................... 154Concevoir un matchmaker ................................................................................................ 154Créer une configuration de mise en relation ........................................................................ 156Créer un ensemble de règles ............................................................................................ 158Configuration de la notification d'événement ........................................................................ 186

Appairage de VPC .................................................................................................................. 187Pour configurer l'appairage de VPC pour une flotte existante ................................................. 188Pour configurer l'appairage de VPC avec une nouvelle flotte .................................................. 189Résolution des problèmes d'appairage de VPC .................................................................... 191

Affichage des données de jeu ........................................................................................................... 193Affichage de l'état actuel d'GameLift .......................................................................................... 193Affichage de vos versions de génération ..................................................................................... 194

Catalogue des versions de génération ................................................................................ 194Détails de version de génération ....................................................................................... 195

Affichage de vos flottes ............................................................................................................ 195Affichage des détails d'une flotte ............................................................................................... 196

Récapitulatif de la flotte .................................................................................................... 196Métriques ....................................................................................................................... 196Événements ................................................................................................................... 197Mise à l'échelle ............................................................................................................... 197Sessions de jeu .............................................................................................................. 198

Versioniv

Amazon GameLift Manuel du développeur

Allocation de capacité ...................................................................................................... 199Ports ............................................................................................................................. 199Build .............................................................................................................................. 199ARN .............................................................................................................................. 199

Affichage des informations de jeu et de joueur ............................................................................ 199Sessions de jeu .............................................................................................................. 200Sessions de joueur .......................................................................................................... 200Informations sur le joueur ................................................................................................. 200

Affichage de vos alias .............................................................................................................. 201Catalogue des alias ......................................................................................................... 201Détails des alias ............................................................................................................. 201

Surveillance d'GameLift .................................................................................................................... 202Surveillance avec CloudWatch .................................................................................................. 202

Métriques GameLift pour les flottes .................................................................................... 202Métriques GameLift pour les files d'attente .......................................................................... 207Métriques GameLift pour l'activité de mise en relation ........................................................... 210Métriques GameLift pour un FleetIQ .................................................................................. 212Dimensions pour les métriques GameLift ............................................................................ 214

Journalisation des appels d'API ................................................................................................. 215Informations Amazon GameLift dans CloudTrail ................................................................... 215Présentation des entrées des fichiers journaux Amazon GameLift ........................................... 215

GameLift FleetIQGuide ..................................................................................................................... 218............................................................................................................................................ 218

GameLift FleetIQLogique .................................................................................................. 219Ressources et composants clés ........................................................................................ 222

Architecture de jeu .................................................................................................................. 223Supplément d’hébergement sur site ................................................................................... 223

Cycles de vie et états .............................................................................................................. 224Processus d’équilibrage des points .................................................................................... 224Durée de vie d’un groupe de serveurs de jeux ..................................................................... 226Durée de vie d’un serveur de jeux ..................................................................................... 227

Configuration .......................................................................................................................... 229Logiciels pris en charge ................................................................................................... 229Configurez votre compte AWS .......................................................................................... 229

............................................................................................................................................ 235Intégrer un serveur de jeux ............................................................................................... 237Intégrer un client de jeu ................................................................................................... 238Gérer les groupes de serveurs de jeux. .............................................................................. 239

Bonnes pratiques .................................................................................................................... 240Surveiller avec CloudWatch ...................................................................................................... 242GameLift FleetIQFonctionnalités de ............................................................................................ 242

Sécurité ......................................................................................................................................... 244Protection des données ............................................................................................................ 244

Chiffrement au repos ....................................................................................................... 246Chiffrement en transit ...................................................................................................... 246Confidentialité du trafic inter-réseaux .................................................................................. 246

Identity and Access Management .............................................................................................. 246Audience ........................................................................................................................ 247Authentification avec des identités ..................................................................................... 247Gestion de l'accès à l'aide de stratégies ............................................................................. 249Comment GameLift fonctionne avec IAM ............................................................................ 251Exemples de stratégie basée sur l'identité ........................................................................... 255Dépannage ..................................................................................................................... 258

Journalisation et surveillance avec GameLift ............................................................................... 260Validation de la conformité ....................................................................................................... 260Résilience .............................................................................................................................. 261Sécurité de l'infrastructure ........................................................................................................ 262

Versionv

Amazon GameLift Manuel du développeur

Configuration et analyse des vulnérabilités .................................................................................. 262Bonnes pratiques de sécurité .................................................................................................... 263

Guides de référence Amazon GameLift .............................................................................................. 264Référence d'API de service (kit SDK AWS) ................................................................................. 264

Utilisation des sessions de jeu et des joueurs ...................................................................... 264Utilisation des ressources d'hébergement ............................................................................ 265Utilisation de la mise en relation FlexMatch ......................................................................... 268Utilisation des GameLift FleetIQ ........................................................................................ 268Langages de programmation disponibles ............................................................................ 269

Référence Serveurs en temps réel ............................................................................................. 269Référence d'API de client en temps réel (C#) ...................................................................... 270Référence des scripts des Serveurs en temps réel ............................................................... 280

Référence SDK Server ............................................................................................................. 286Référence d'API de serveur pour C++ ................................................................................ 286Référence d'API de serveur pour C++ ................................................................................ 301Référence d’API de serveur pour Unreal Engine .................................................................. 316

Référence FlexMatch ............................................................................................................... 324Schéma d'ensemble de règles .......................................................................................... 324Langage des règles ......................................................................................................... 331Événements de mise en relation ....................................................................................... 337

Notes de mise à jour ....................................................................................................................... 346Versions SDK ......................................................................................................................... 346Notes de mise à jour ............................................................................................................... 348Compatibilité Lumberyard ......................................................................................................... 352

Historique du document. .................................................................................................................. 353Glossaire AWS ............................................................................................................................... 375............................................................................................................................................... ccclxxvi

Versionvi

Amazon GameLift Manuel du développeurPourquoi choisir GameLift ?

Présentation d'Amazon GameLift?Amazon GameLift permet aux développeurs de déployer, d'exploiter et de mettre à l'échelle desserveurs dédiés à faible coût dans le cloud pour les jeux multijoueurs basés sur les sessions. Basé surl'infrastructure de calcul globale d'AWS, GameLift permet de proposer des serveurs de jeux extrêmementperformants et fiables pour un faible coût, avec une mise à l'échelle dynamique en fonction de l'utilisationdes ressources afin de répondre aux besoins des joueurs au niveau mondial.

Pourquoi choisir GameLift ?Voici quelques-uns des avantages liés à l'utilisation d'Amazon GameLift:

• Ajoutez vos propres serveurs de jeu multijoueur entièrement personnalisés ou utilisez les Serveurs entemps réel prêts à l'emploi qui nécessitent une configuration minimale et peu ou pas d'expérience.

• Expérience joueur à faible latence pour la prise en charge d'un jeu rapide.• Améliorez vos services de mise en relation grâce à la mise en file d'attente et au placement de session

de jeu intelligents, ainsi qu’au remplissage des parties.• Réduction de l'effort d'ingénierie et de l'effort opérationnel pour le déploiement et l'exploitation des

serveurs de jeux.• Mise en route rapide et paiement à l'utilisation, sans frais initiaux ni engagements à long terme.• Réduisez les coûts jusqu'à 90 % avec les instances Spot.• Compter sur Amazon Web Services (AWS), y compris Amazon Elastic Compute Cloud (Amazon EC2)

pour les ressources informatiques en nuage à l’échelle du Web et la mise à l’échelle automatique pourgérer votre capacité d’hébergement.

Conseil

Informez-vous sur les façons d'explorer les fonctions Amazon GameLift, en particulier Serveurs entemps réel, à l'aide des exemples de jeux. (p. 32).

GameLift solutionsGameLift propose une gamme de solutions pour les développeurs de jeux :

• GameLift hébergeant des serveurs de jeux personnalisés.• GameLift hébergement avec Serveurs en temps réel• GameLift FleetIQ optimisations d’hébergement de jeux pour utilisation avec Amazon EC2

GameLift hébergementAmazon GameLift offre un service entièrement géré conçu pour le déploiement, l'exploitation et lamise à l'échelle de serveurs de jeux multijoueurs basés sur des sessions. GameLift effectue les tâchesnécessaires à l'hébergement de vos propres serveurs de jeux personnalisés, notamment l'achat et laconfiguration du matériel, ainsi que la gestion de l'activité en cours, de la sécurité, du stockage et le suivi

Version1

Amazon GameLift Manuel du développeurGameLift hébergement avec Serveurs en temps réel

des performances. Des fonctionnalités de scalabilité automatique offrent une protection supplémentairepour éviter d’avoir à payer plus de ressources que nécessaire, tout en s’assurant que les nouveaux joueurspuissent se connecter à un jeu avec un temps d'attente minimal.

Pour en savoir plus sur la façon dont la solution d’hébergement de gamelift fonctionne, voir Fonctionnementd'un Amazon GameLift (p. 3).

Fonctions principales :

• Offrir un hébergement de jeux de haute qualité aux joueurs du monde entier en déployant desressources informatiques en plusieurs AWS Régions.

• Déploiement de serveurs de jeux qui s'exécuteront sur les systèmes d'exploitation Amazon Linux ouWindows Server.

• Laisser FleetIQ optimiser l’utilisation des instances spot à faible coût. À elles seules, les instancesSpot ne sont pas toujours viables pour l'hébergement de jeux en raison des risques d'interruption. Lesalgorithmes de prédiction FleetIQ identifient les instances Spot les mieux adaptées pour héberger denouvelles sessions de jeu.

• Les outils de mise à l'échelle automatique permettent d'ajuster votre capacité d'hébergement de jeux afinde répondre à la demande réelle des joueurs. Ces outils vous permettent de garder la maîtrise des coûtsd'hébergement tout en préservant une capacité suffisante pour intégrer rapidement de nouveaux joueurs.

• Avec , créez un service de mise en relation personnalisé pour votre jeu.FlexMatch. Créez des parties àune ou à plusieurs équipes pour un maximum de 200 joueurs.

• Gestion des sessions de jeu et des sessions de joueur. Configuration de caractéristiques de sessionde jeu, comme le nombre maximum de joueurs autorisés, les règles de participation et les propriétésspécifiques au jeu.

• Gamme d'options pour aider les joueurs à trouver des sessions de jeu appropriées. Utilisez lesfiles d'attente GameLift pour placer intelligemment de nouvelles sessions de jeu dans plusieursrégions, fournir aux joueurs des listes filtrées et triées des sessions de jeu disponibles (« répertorier etsélectionner ») ou implémenter un système de mise en relation complet avec FlexMatch.

• Analyse des performances de jeu à l'aide de la console Amazon GameLift pour le suivi des métriques,l'affichage des journaux de session de jeu et la vérification des données dans les sessions de jeuindividuelles et les sessions de joueur.

• Configuration d'un suivi de statut personnalisé afin que les processus serveur puissent détecter etrésoudre rapidement les problèmes rapides et résoudre les processus peu performants.

• Gérez vos ressources de jeu à l'aide de modèles AWS CloudFormation pour GameLift.

GameLift hébergement avec Serveurs en temps réelUtilisez Serveurs en temps réel pour mettre en place des jeux qui n'ont pas besoin de serveurs de jeuxconçus sur mesure. Cette solution de serveur léger fournit des serveurs de jeux prêts à l'emploi qui peuventêtre configurés pour correspondre à votre jeu. Vous pouvez déployer des serveurs de jeux de différentesmanières, d'un minimum de paramètres de configuration à une logique personnalisée spécifique à votre jeuet aux joueurs.

Pour en savoir plus sur comment GameLift hébergement avec Serveurs en temps réel fonctionne, voirFonctionnement des Serveurs en temps réel (p. 9).

Fonctions principales :

• Utiliser GameLift des fonctions de gestion, y compris l’auto-échelle, les files d’attente multi-régions, lamise en place de la session de jeu avec FleetIQ, la journalisation des sessions de jeu et les mesures.

• Utiliser GameLift ressources d’hébergement, choisissez le type de AWS matériel informatique pour vosflottes. Utilisez des instances Spot ou à la demande.

• Profitez d'une pile réseau complète pour l'interaction client/serveur de jeu.

Version2

Amazon GameLift Manuel du développeurGameLift FleetIQ pour l’hébergement Amazon EC2

• Bénéficiez des fonctionnalités intrinsèques du serveur de jeux avec une logique de serveurpersonnalisable.

• Effectuez des mises à jour en direct des configurations RealTime et de la logique du serveur. Mettez àjour la configuration de votre serveur RealTime à tout moment.

• Mise en œuvre FlexMatch matchmaking.

GameLift FleetIQ pour l’hébergement Amazon EC2GameLift FleetIQ optimise l'utilisation d'instances Spot à faible coût pour l'hébergement de jeux dans lecloud. Avec cette fonctionnalité, vous pouvez travailler directement avec vos ressources d’hébergementdans Amazon EC2 et Auto Scaling et profitez de GameLift d’optimisation pour offrir un hébergement de jeupeu coûteux et résilient pour vos joueurs. Cette solution est conçue pour les développeurs de jeux qui ontbesoin de plus de flexibilité que celle offerte dans le cadre de la gestion complète GameLift solutions.

Pour en savoir plus sur comment GameLift FleetIQ fonctionne avec Amazon EC2 et Auto Scaling pourl’hébergement des jeux, voir GameLift FleetIQGuide (p. 218).

Fonctions principales :

• Obtenez un équilibrage optimisé des points grâce à GameLift FleetIQ algorithmes de prédiction.• Utilisez des fonctions de routage de joueurs pour gérer efficacement vos ressources de serveur de jeu et

offrir une expérience de joueur optimale lors de la jointure de jeux.• Évolutivité automatique de la capacité d’hébergement basée sur l’utilisation du lecteur.• Gestion directe des instances Amazon EC2 dans votre propre compte AWS.• Utilisation des formats exécutables de serveur de jeux pris en charge, y compris Windows, Linux, les

conteneurs et Kubernetes.• Choisissez parmi plusieurs types de Amazon EC2 ressources informatiques.• Accès aux joueurs du monde entier grâce au déploiement dans 15 régions, y compris la Chine.

Fonctionnement d'un Amazon GameLiftCette rubrique offre une présentation générale de la solution Amazon GameLift gérée. Elle aborde lescomposants de base et décrit la façon dont le service met vos serveurs de jeux multijoueur à la dispositiondes joueurs. Si vous souhaitez en savoir plus sur les possibilités et le fonctionnement de la solutionGameLift gérée, commencez par lire cette rubrique et les rubriques connexes suivantes. Pour en savoirplus sur les autres solutions GameLift, veuillez consulter Présentation d'Amazon GameLift? (p. 1).

• Comment les joueurs se connectent aux Jeux (p. 13)• Moteurs de jeux et Amazon GameLift (p. 37)• Pourquoi utiliser des files d'attente ? (p. 144)• Fonctionnement d'Amazon GameLift FlexMatch (p. 15)

Prêt à commencer à préparer votre jeu pour l'hébergement sur GameLift ? Consultez ces Démarrez avecAmazon GameLift (p. 32) rubriques, y compris les feuilles de route d'intégration.

Composants clésLa configuration d'Amazon GameLift pour héberger votre jeu implique l'utilisation de composants clés.Les relations entre ces composants sont illustrées dans Architecture de jeu avec solution GameLift gérée (p. 19).

Version3

Amazon GameLift Manuel du développeurHébergement de serveurs de jeux

• Un serveur de jeux est le logiciel de votre serveur de jeux qui s'exécute dans le cloud. Vous téléchargezvotre build du serveur de jeux (ou script si vous utilisez Serveurs en temps réel (p. 9)) au AmazonGameLift de service et de dire GameLift combien de processus de serveur de jeux doivent avoir en coursd’exécution à un moment donné. Les processus du serveur de jeux peuvent héberger une session de jeuà la fois.

• A session de jeu est votre jeu en cours, avec un point de départ et un point de fin qui est défini par votrejeu. Vous définissez les caractéristiques de base d'une session de jeu, comme sa durée de vie ou lenombre de joueurs. Les joueurs se connectent au serveur de jeux pour rejoindre une session de jeu.

• Le service Amazon GameLift gère les ressources informatiques nécessaires à l'hébergement de votreserveur de jeux et permet aux joueurs de se connecter aux jeux. Il régule le nombre de ressourcesen fonction de la demande des joueurs, démarre les nouvelles sessions de jeu, et gère les demandesd'accès des joueurs en recherchant et en réservant les emplacements des joueurs dans les sessionsde jeu actives. Le service collecte également des métriques sur l'état du serveur et sur l'utilisation desjoueurs.

• Un client de jeu est le logiciel de votre jeu qui s'exécute sur le dispositif d'un joueur. Un client de jeuenvoie des demandes au service GameLift sur les sessions de jeu disponibles. Il se connecte égalementdirectement à une session de jeu à l'aide des informations qu'il reçoit du service GameLift.

• Les services de jeu sont des services personnalisés supplémentaires que vous pouvez créer pourgérer les tâches spéciales liées à GameLift. Par exemple, la plupart des jeux utilisent un service clientpour gérer la communication avec le service GameLift plutôt que les clients de jeu appellent le servicedirectement.

Pour une description détaillée de le manière dont ces éléments interagissent, consultez GameLift etinteractions client/serveur de jeu (p. 58).

Hébergement de serveurs de jeuxVos serveurs de jeux chargés sont hébergés sur les ressources informatiques Amazon GameLift virtuelles,appelées instances. Vous configurez vos ressources d'hébergement en créant une flotte d'instances et enles déployant pour exécuter votre serveur de jeux (votre serveur de jeux personnalisé ou votre Serveurs entemps réel configuré). Vous pouvez concevoir une flotte en fonction des besoins de votre jeu.

Architecture de flotte

Créez une flotte qui répond à vos besoins principaux.

• De quel type de ressources votre jeu a-t-il besoin ? – GameLift prend en charge un large éventailde systèmes d'exploitation et de types d'instance. Le type d'instance détermine le type de matérielinformatique utilisé, y compris la puissance de traitement, la mémoire et la capacité de mise enréseau. Notez que les coûts de flotte sont basés à la fois sur le type et le nombre d'instances quevous utilisez. En fonction des exigences de votre jeu, vous pouvez choisir d'utiliser de nombreusespetites instances ou moins d'instances plus puissantes. Découvrez comment Choisir des ressourcesinformatiques (p. 111).

• Où voulez-vous exécuter vos serveurs de jeux ? – Vous configurez des flottes partout où des joueursattendent de rejoindre vos jeux. Chaque flotte est déployée dans une seule région AWS, mais vouspouvez créer des flottes dans autant de régions que nécessaire. Consultez la liste des régionsdisponibles pour Amazon GameLift dans Régions et points de terminaison AWS.

• Dans quelle mesure la fiabilité du serveur de jeux est-elle critique ? – Votre parc utilise des instancesSpot ou des instances à la demande. Les instances Spot (basées sur les instances Spot EC2) coûtentgénéralement moins cher, mais peuvent être interrompues pendant une session de jeu. Cependant,GameLift dispose de protections supplémentaires qui rendent les interruptions de session de jeuextrêmement rares ; de plus, les flottes avec instances Spot constituent un bon choix pour la plupart desjeux. En revanche, les instances à la demande fournissent une disponibilité constante, mais peuvents'avérer plus onéreuses. Elles constituent une bonne option pour les jeux où les joueurs sont fortement

Version4

Amazon GameLift Manuel du développeurExécution des sessions de jeu

affectés si une session de jeu est interrompue. En savoir plus sur Instances À la demande et InstancesSpot (p. 112).

• Combien de joueurs avez-vous besoin de soutenir ? – Une flotte peut avoir de nombreuses instances,chacune capable d’héberger plusieurs sessions de jeu simultanées. Vous pouvez ajouter ousupprimer des instances de votre flotte si nécessaire. Vous pouvez également utiliser la scalabilitéautomatique pour ajuster automatiquement en fonction de la demande des joueurs. En savoir plus surDimensionnement de la capacité d'une flotte (p. 6).

Configuration d'exécution du serveur

Une instance de flotte peut exécuter plusieurs processus simultanément. Elle peut aussi exécuter n'importequel exécutable dans votre build de serveur de jeux. Pour déterminer comment les processus doivents'exécuter sur chaque instance, vous créez une configuration d'exécution. La configuration spécifie : (1) lesexécutables à exécuter, (2) le nombre de processus de chaque exécutable à exécuter simultanément et (3)les paramètres de lancement à utiliser lors du démarrage de chaque exécutable. Le nombre de processusqu'une instance peut exécuter simultanément dépend de la puissance de calcul de l'instance (typed'instance), ainsi que des exigences de la build de votre serveur de jeux. En savoir plus sur l'exécution deplusieurs processus sur une flotte (p. 113). Les configurations d'exécution peuvent être mises à jour toutau long de la durée de vie de la flotte.

Une configuration d'exécution peut également affecter la façon dont les nouvelles sessions de jeu sontdémarrées sur une instance. Certains jeux nécessitent beaucoup de ressources au cours de la phasede démarrage ; il peut donc être judicieux de limiter les ressources d'instance utilisées pour activer denouvelles sessions de jeu à tout moment. Vous pouvez spécifier un nombre maximal d'activations desession de jeu simultanées par instance. Vous pouvez également définir une limite de temps pour chaqueactivation de session de jeu afin de détecter et d'arrêter rapidement toutes les sessions de jeu qui neparviennent pas à s'activer.

Sécurité des serveurs

Activez la génération de ressources PKI pour une flotte. Lorsque cette fonctionnalité est activée, GameLiftgénère un certificat TLS pour la flotte et crée une entrée DNS pour chaque instance de la flotte. Avec cesressources, votre jeu peut authentifier la connexion client et serveur, et chiffrer toutes les communicationsclient/serveur de jeu. Cette fonctionnalité est particulièrement utile lors du déploiement de jeux multijoueursmobiles. Ces services sont fournis via AWS Certificate Manager (ACM) et sont actuellement disponiblessans frais supplémentaires.

Alias de flotte

Un alias est une dénomination qui peut être transférée d'une flotte à une autre, ce qui en fait un moyenpratique de généraliser l'emplacement d'une flotte. Par exemple, votre client de jeu doit spécifier où(dans quelle flotte) placer une nouvelle session de jeu. L'utilisation d'un alias vous permet de basculerles clients de jeu d'une flotte à une autre sans avoir à modifier votre client de jeu. Il existe plusieursfonctions GameLift dans lesquelles vous avez la possibilité de spécifier une flotte ou un alias. Vous pouvezégalement créer un alias de « terminal », qui vous permet de pointer vers le contenu (par exemple, uneURL) au lieu de vous connecter à un serveur. Cette fonctionnalité peut être utile, par exemple, pour inviterles joueurs à mettre à niveau leurs clients.

Exécution des sessions de jeuDès qu'une build de serveur de jeux est déployée à dans une flotte, celle-ci est prête pour l'hébergementde sessions de jeu. Pour démarrer une nouvelle session de jeu pour un ou plusieurs joueurs, votre clientde jeu envoie une demande (via un service de jeu) au service GameLift. Lorsque la demande est reçue,GameLift utilise une fonction appelée FleetIQ pour placer la nouvelle session de jeu avec la « meilleureflotte possible ».

C’est vous qui déterminez quelle est la « meilleure flotte possible » et ce, en fonction de vos prioritésde jeu, lorsque vous définissez une file d'attente de sessions de jeu. Une file d'attente crée un groupe

Version5

Amazon GameLift Manuel du développeurDimensionnement de la capacité d'une flotte

d'une ou plusieurs flottes et définit comment choisir la meilleure flotte dans le groupe pour une nouvellesession de jeu. Les files d'attente peuvent contenir des flottes qui se situent dans différentes régions. Unenouvelle demande de session de jeu spécifie la file d'attente à utiliser et GameLift peut placer la nouvellesession de jeu avec n'importe quelle flotte disponible dans la file d'attente. Par exemple, vous pouvezutiliser une file d'attente avec des flottes dans chacune des cinq régions d'Amérique du Nord. Avec une filed'attente à plusieurs régions, GameLift est plus susceptible de trouver des ressources disponibles (mêmeen cas de trafic élevé) et de démarrer rapidement une nouvelle session de jeu. La disponibilité de la flottesignifie simplement qu'il y a au moins une instance dans la flotte avec un processus serveur de jeux prêt àhéberger une nouvelle session de jeu.

Pour choisir le meilleur placement possible pour une session de jeu, FleetIQ utilise l'une des deuxméthodes suivantes :

• Evaluate player latency ( Évaluer la latence des joueurs) – Les demandes de nouvelles sessions de jeupeuvent inclure un temps ping pour chaque joueur de la demande. Si ces données sont fournies, FleetIQles évalue pour déterminer quelles régions fourniront la latence la plus faible possible pour les joueurs.GameLift utilise ces informations pour placer la nouvelle session de jeu. Vous pouvez également définirdes stratégies de latence pour vous assurer que les joueurs ne sont jamais placés dans des sessions dejeu avec une latence inacceptable.

• Utiliser la liste des flottes prioritaires – Pour les demandes qui ne contiennent pas de données de latencepour les joueurs, FleetIQ place de nouvelles sessions de jeu en fonction de l'ordre dans lequel les flottessont répertoriées dans la file d'attente. Vous pouvez prioriser les flottes dans une file d'attente en lesplaçant en haut de la liste des flottes. Cette méthode permet généralement de placer toutes les sessionsde jeu avec la première flotte listée, les flottes restantes servant de sauvegardes lorsque la premièreflotte est pleine.

La file d'attente est un concept puissant qui peut être utilisé pour résoudre un large éventail de problèmesde capacité et de disponibilité. Les files d'attente permettent d’équilibrer l'utilisation des ressourcesentre les régions, de réduire le temps d'attente pour les joueurs en cas de pics de demande imprévuset d’atténuer les ralentissements ou les pannes dans les régions. Vous pouvez également les utiliserpour créer des pools de joueurs qui couvrent plusieurs régions, afin que des joueurs de différentesrégions puissent jouer ensemble. Les files d'attente sont requises lors de l'utilisation de la mise en relationFlexMatch ou des parcs d'instances Spot GameLift. Découvrez comment Conception d'une file d'attente desession de jeu (p. 143).

Une fois qu'une session de jeu est démarrée sur une instance de flotte, le service GameLift fournit desinformations de connexion au client de jeu, sous la forme d'une adresse IP ou d'un nom DNS et d'un port.Votre client de jeu utilise ces informations pour se connecter à votre serveur de jeux. En fonction de lafaçon dont vous configurez votre serveur de jeux, lors de la connexion, il peut communiquer avec le serviceGameLift pour vérifier le joueur et signaler le statut de connexion du joueur.

Si la flotte a été créée avec un certificat TLS, votre client de jeu et votre serveur peuvent l'utiliser pourétablir une connexion sécurisée.

Dimensionnement de la capacité d'une flotteDès qu'un parc est actif et prêt à héberger des sessions de jeu, vous devez ajuster la capacité du parc pourrépondre à la demande des joueurs. Le coût d'hébergement est basé sur la quantité de capacité que vousutilisez. Par conséquent, vous voudrez trouver un équilibre entre s'assurer que tous les joueurs entrantspeuvent trouver un jeu et les dépenses excessives sur les ressources qui restent inactives.

Vous dimensionnez un parc en ajustant son nombre d'instances. Votre configuration d'exécution déterminele nombre de sessions de jeu et de joueurs que chaque instance peut héberger. Par conséquent, endimensionnant les instances, vous augmentez ou diminuez la disponibilité des sessions de jeu et desjoueurs. GameLift fournit un outil de scalabilité automatique très efficace, ou vous pouvez choisir de définirmanuellement la capacité de la flotte. Découvrez comment Dimensionnement de la capacité d'une flotteGameLift (p. 133).

Version6

Amazon GameLift Manuel du développeurDimensionnement de la capacité d'une flotte

Scalabilité automatiqueGrâce à la fonction de scalabilité automatique, GameLift suit les métriques d'hébergement de la flotteet détermine s'il est nécessaire d'ajouter ou de retirer des instances en fonction d'un ensemble derecommandations que vous définissez. Avec les bonnes stratégies de dimensionnement automatique enplace, GameLift peut ajuster la capacité directement en réponse aux modifications de la demande desjoueurs. En savoir plus sur l'amélioration de l'efficacité économique avec la mise à l'échelle automatique.

Il existe deux méthodes de scalabilité automatique disponibles :

• Mise à l'échelle basée sur la cible – Avec cette méthode, vous spécifiez un résultat souhaité et GameLiftdimensionne la flotte à la hausse ou à la baisse pour atteindre ce résultat. Le suivi de la cible utilisela métrique « pourcentage de sessions de jeu disponibles », c'est-à-dire le pourcentage de processusserveur sains qui n'hébergent pas actuellement une session de jeu. Les sessions de jeu disponiblesconstituent votre tampon : elles représentent le nombre de nouvelles sessions de jeu et de nouveauxjoueurs qui peuvent rejoindre un jeu avec un temps d'attente minimal. Avec le suivi de la cible, vouschoisissez la taille de tampon qui correspond à votre jeu. Par exemple, pour un jeu avec une demandehautement volatile, vous pouvez avoir besoin d'une taille de tampon plus importante. Cette méthode estl'option préférée, car elle est plus simple et plus efficace pour la plupart des jeux. En savoir plus sur lefonctionnement du Suivi de la cible.

• Dimensionnement basé sur les règles – Cette méthode vous offre un contrôle plus précis des actionsde dimensionnement. Il est également plus complexe de configurer et de gérer, et il est plus susceptibled'avoir des résultats inattendus. Chaque stratégie spécifie quand déclencher un événement dedimensionnement et quelle action prendre en réponse. Par exemple, une stratégie peut indiquer : "Si lesinstances inactives tombent en dessous de 20 pendant 10 minutes consécutives, augmentez la capacitéde 10 %." La plupart des flottes nécessitent plusieurs stratégies pour gérer efficacement la capacité de laflotte, mais plusieurs stratégies peuvent avoir des effets combinés inattendus, ce qui complique la tâche.Découvrez comment Mise à l'échelle automatique avec des stratégies basées sur les règles (p. 139).

Dimensionnement de parc en actionUn événement de dimensionnement de parc peut être déclenché de différentes manières, soit en effectuantune modification de la capacité souhaitée via la scalabilité automatique ou un dimensionnement manuel, oulorsque des instances sont arrêtées des raisons de santé ou d'autres raisons. Fondamentalement, tous lesévénements de dimensionnement sont déclenchés lorsque le nombre d'instances « souhaité » d'un parc necorrespond pas à son nombre d'instances « actives ». Dans ce cas, Amazon GameLift ajoute ou retire desinstances, en fonction des besoins, afin de faire correspondre le nombre d'instances actives et le nombred'instances souhaitées.

• Lorsque le nombre d'instances souhaitées dépasse le nombre d'instances actives, Amazon GameLiftdemande des instances supplémentaires et, une fois qu'elles sont disponibles, il commence le processusd'installation de la génération du serveur de jeux pour les nouvelles instances et le démarrage desprocessus de serveur de jeux. Dès qu'un processus serveur est actif sur une instance, le nombred'instances actives augmente de un. Amazon GameLift continue à ajouter des instances jusqu'à ce queles deux valeurs de compte soient égales.

• Lorsque le nombre d'instances actives dépasse le nombre d'instances souhaitées, Amazon GameLiftcommence à rechercher les instances qu'il peut supprimer. Toute instance disponible (c'est-à-dire,qui n'héberge pas de sessions de jeu) peut être résiliée, ainsi que toute instance non protégée, mêmelorsqu'elle héberge des sessions de jeu actives. Si aucune instance ne peut être supprimée, l'événementde dimensionnement à la baisse échoue. Dans ce cas, l'écart entre le nombre d'instances désirées et lenombre d'instances actives continue de déclencher des événements de dimensionnement à la baissejusqu'à ce qu'une instance puisse être supprimée. Amazon GameLift démarre ensuite le processusde résiliation, qui inclut une notification envoyée à tous les processus serveur sur l'instance afin qu'ilslancent un arrêt normal. Dès que l'instance est résiliée, le nombre d'instances actives diminue de un.Amazon GameLift continue à supprimer des instances jusqu'à ce que les deux valeurs de compte soientégales.

Version7

Amazon GameLift Manuel du développeurSupervision de l'activité de la flotte et dépannage

Fonctionnalités de mise à l'échelle supplémentairesLes fonctionnalités supplémentaires liés à la capacité du parc et au dimensionnement sont les suivantes :

• Game session protection (Protection de la session de jeu) – Évite que les sessions de jeu qui hébergentdes joueurs actifs ne soient résiliées lors d'un événement de dimensionnement à la baisse. La protectionde session de jeu peut être activée au niveau du parc, ou elle peut être activée pour des sessions dejeu individuelles. Une instance ne peut pas être résiliée si l'un de ses processus serveur héberge dessessions de jeu protégées. Les sessions de jeu ne sont pas protégés contre les résiliations dues àdes interruptions liées à la santé ou à des instances Spot (voir Instances À la demande et InstancesSpot (p. 112)).

• Limites de dimensionnement – Permet de contrôler l'utilisation globale des instances par la définitionde limites minimum et maximum du nombre d'instances d'une flotte. Ces limites s'appliquent lors de lascalabilité automatique ou du dimensionnement manuel de la capacité.

• Enabling/disabling auto-scaling (Activation/désactivation de la scalabilité automatique) – Permet d'activerou de désactiver la scalabilité automatique au niveau de la flotte sans modifier ou supprimer vosstratégies de scalabilité automatique. Cette fonctionnalité vous permet de dimensionner temporairementvos parcs manuellement lorsque cela est nécessaire.

• Scaling metrics (Métriques de dimensionnement) – Permet de suivre l'historique de capacité et lesévénements de dimensionnement d'une flotte sous forme graphique. Affichez la capacité avec desmétriques d'utilisation de parc afin d'évaluer l'efficacité de votre approche de dimensionnement. Legraphique suivant illustre un parc avec le suivi de la cible défini sur un tampon de 15 % ; le pourcentagede disponibilité des emplacements de session de jeu (en vert) s'ajuste automatiquement dès que lacapacité du parc (en bleu et orange) change.

Supervision de l'activité de la flotte et dépannageLorsque vos flottes sont opérationnelles, Amazon GameLift collecte différents types d'informations pourvous aider à contrôler les performances de vos serveurs de jeux déployés. Utilisez ces informations pouroptimiser votre utilisation des ressources, résoudre les problèmes et mieux comprendre comment lesjoueurs sont actifs dans vos jeux.

• Fleet, game session, and player session details (Flotte, session de jeux et détails de session de joueur)– Ces données incluent le statut, ce qui peut aider à identifier les problèmes d'état, ainsi que des détailscomme la longueur d'une session de jeu et le temps de connexion d'un joueur.

• Utilization metrics (Métriques d'utilisation) – Amazon GameLift suit les métriques de flotte dans le temps :• Pour les instances : activité du réseau et utilisation de l'UC• Pour les processus serveur : nombre de processus actifs, nouvelles activations, et résiliations• Pour les jeux et les joueurs : nombre de sessions de jeu et de sessions joueur actives

• Server process health (État des processus serveur) – Amazon GameLift suit l'état de chaque processusserveur qui s'exécute sur une flotte, notamment le nombre de processus sains, le pourcentage deprocessus actifs qui sont sains et le nombre de résiliations anormales.

• Game session logs (Journaux de sessions de jeu) – Vous pouvez configurer vos serveurs de jeux afinqu'ils consignent les données de session et définir Amazon GameLift pour qu'il collecte et stocke lesjournaux à la fin d'une session de jeu. Les journaux peuvent ensuite être téléchargés à partir du service.

Toutes ces données sont disponibles via la console Amazon GameLift. Le tableau de bord de la consoleprésente une vue d'ensemble de l'activité sur l'ensemble de vos versions de génération ainsi qu'une optionpermettant d'afficher plus d'informations.

Version8

Amazon GameLift Manuel du développeurMise en réseau avec les ressources AWS

Mise en réseau avec les ressources AWSDans de nombreuses situations, vous souhaitez que vos serveurs de jeux et applications hébergéspuissent communiquer avec vos autres ressources AWS. Par exemple, vous pouvez utiliser un ensemblede services web pour prendre en charge votre jeu, tels que l'authentification du joueur ou les réseauxsociaux. Ce type de communication présente des difficultés en raison de problèmes de propriété. Lorsquevous déployez des serveurs de jeux à l'aide d'Amazon GameLift, les flottes et les instances sont allouéesà votre compte, mais elles sont détenues et gérées par le service Amazon GameLift. Par conséquent, pouraccéder aux ressources AWS qui sont gérées par votre compte AWS, vous devez autoriser explicitementl'accès par le service Amazon GameLift.

Amazon GameLift fournit plusieurs options pour la gestion de ce type d'accès. Découvrez commentCommuniquez avec d’autres ressources AWS de vos flottes (p. 49).

Fonctionnement des Serveurs en temps réelCette rubrique fournit une vue d'ensemble de la solution Amazon GameLift gérée avec Serveurs entemps réel. Elle explique quand la solution est adaptée à votre jeu et comment les Serveurs en temps réelprennent en charge les jeux multijoueurs. Pour en savoir plus sur les autres solutions GameLift, veuillezconsulter Présentation d'Amazon GameLift? (p. 1).

Que sont les serveurs en temps réel ?Les serveurs Serveurs en temps réel sont des serveurs de jeux légers et prêts à l'emploi qui sont fournispar GameLift pour que vous puissiez les utiliser avec vos jeux multijoueur. Bien que de nombreux jeuxaient besoin d'un serveur de jeux personnalisé pour gérer les calculs physiques et les calculs complexes,cela est excessif pour de nombreux autres jeux. Comme avec Serveurs en temps réel il n'est plusnécessaire de développer, tester et déployer un serveur de jeux personnalisé, le choix de cette solutionpeut vous aider à réduire le temps et les efforts nécessaires pour terminer votre jeu.

Les principales fonctionnalités sont les suivantes :

• Pile réseau complète pour l'interaction client/serveur de jeu. Serveurs en temps réel utilise les canauxTCP et UDP pour la messagerie. Vous pouvez également choisir d'utiliser l'authentification serveurintégrée et le chiffrement des paquets de données en activant les certificats TLS générés par GameLift.

• Fonctionnalité de serveur de jeux de base. Un serveur RealTime démarre (et arrête) les sessions de jeu,gère les données de jeu et de relation, et accepte les connexions client. Le serveur de jeux maintient unétat de session de jeu synchronisé en recevant des informations d'état de jeu de chaque client et en lesrelayant à d'autres clients dans la session de jeu.

• est intégré au service GameLift. Un serveur RealTime est configuré pour communiquer avec le serviceGameLift, ce qui permet au serveur RealTime de démarrer des sessions de jeu, de valider les joueurslorsqu'ils se connectent et de collecter l'état de connexion des joueurs et l'état d'intégrité du jeu à partirdu serveur de jeu. En revanche, cette fonctionnalité doit être implémentée dans un serveur de jeupersonnalisé.

• Logique serveur personnalisable. Vous pouvez configurer vos serveurs RealTime et les personnaliseravec la logique de jeu côté serveur qui convient le mieux à votre jeu. Vous pouvez également fournir uneconfiguration minimale et l'utiliser comme simples serveurs relais. En savoir plus sur Personnalisationd'un serveur RealTime (p. 12).

• Mises à jour en direct des configurations RealTime et de la logique du serveur. Mettez à jour laconfiguration de votre serveur RealTime à tout moment. GameLift vérifie régulièrement les scripts deconfiguration mis à jour. Dès lors, une fois que vous chargez une nouvelle version, elle est rapidementdéployée dans votre flotte et utilisée avec toutes les nouvelles sessions de jeu.

• Mise en relation avec FlexMatch. Les clients de jeu qui utilisent Serveurs en temps réel peuvent utilisertoutes les fonctions de mise en relation FlexMatch, y compris pour les rencontres volumineuses.

Version9

Amazon GameLift Manuel du développeurChoix de Serveurs en temps réel pour votre jeu

• Contrôle flexible des ressources d'hébergement. Pour les jeux déployés avec Serveurs en temps réel,vous pouvez utiliser toutes les fonctions de gestion GameLift, y compris la scalabilité automatique, lesfiles d'attente sur plusieurs régions, le placement de session de jeu avec FleetIQ, la journalisation desession de jeu et les métriques. Vous déterminez la manière dont vos ressources d'hébergement sontutilisées.

• Plage d'options de ressources informatiques. Les serveurs RealTime s'exécutent sur Linux. Vouschoisissez le type de matériel informatique pour votre flotte et si vous souhaitez utiliser des instancesSpot ou des instances à la demande.

• Fiabilité d'AWS. Comme pour l'ensemble des GameLift, les ressources d'hébergement avec Serveurs entemps réel apportent le haut niveau de qualité, de sécurité et de fiabilité d'AWS.

Configurez les serveurs RealTime en créant une flotte de ressources d'hébergement et en fournissant unscript de configuration. En savoir plus sur la création de serveurs RealTime et sur la préparation de votreclient de jeu dans Premiers pas avec Serveurs en temps réel (p. 35).

Choix de Serveurs en temps réel pour votre jeuChoisir Serveurs en temps réel au lieu de créer un serveur de jeux personnalisé se résume principalementau besoin de votre jeu en termes de complexité du serveur. À moins que votre jeu n'ait besoin d'unelogique de jeu compliquée côté serveur, de calculs en fraction de seconde pour la logique du gameplay oud'autres capacités personnalisées, Serveurs en temps réel peut constituer la meilleure solution pour votrejeu. Les jeux qui utilisent Serveurs en temps réel pour le meilleur effet sont légers ou gèrent une grandepartie du travail de calcul sur le client de jeu. Par exemple, on peut citer les jeux de messagerie, les jeux destratégie tour à tour et de nombreux types de jeux mobiles. Serveurs en temps réel, couplé à l'utilisation deFleetIQ, fournit des outils efficaces permettant de minimiser la latence des joueurs dans presque tous lestypes de jeu.

Composants clésLorsque vous travaillez avec Serveurs en temps réel, vous utilisez les composants suivants. Découvrezces composants et leur fonctionnement commun dans Architecture de jeu avec Serveurs en tempsréel (p. 21).

• Un serveurRealTime fournit la mise en réseau client/serveur pour votre jeu. Il démarre les sessionsde jeu lorsqu'elles sont déclenchées par le service GameLift, demande une validation pour les joueurslorsqu'ils se connectent et signale les connexions du joueur d'état et l'état du jeu. Le serveur transmet lesdonnées d'état du jeu entre tous les joueurs connectés et exécute une logique de jeu personnalisée sielle est fournie.

• Un client de jeu est le logiciel de votre jeu qui s'exécute sur le dispositif d'un joueur. Le client de jeu (viaun service client) envoie des demandes au service GameLift pour trouver les sessions de jeu à rejoindreou en démarrer de nouvelles, et se connecte à un serveur RealTime pour participer à un jeu. Une foisconnecté, un client de jeu peut envoyer et recevoir des données, via le serveur RealTime, avec d'autresjoueurs dans le jeu.

• Un script RealTime fournit les paramètres de configuration et une logique de jeu personnaliséefacultative de votre jeu. Le script peut comporter un minimum de paramètres de configuration ouune logique de jeu plus complexe. Le script RealTime est déployé avec le serveur RealTime lors dudémarrage de nouvelles ressources d'hébergement. Les scripts sont écrits en JavaScript basé surNode.js.

• Le service GameLift gère les ressources informatiques nécessaires à l'hébergement de vos serveursRealTime et permet aux joueurs de se connecter aux jeux. Il régit le nombre de ressources pour lademande des joueurs, gère les demandes de participation des joueurs en recherchant et en réservantdes emplacements de joueur dans des sessions de jeu actives, déclenche les serveurs RealTime pourdémarrer les sessions de jeu et valide les joueurs lorsqu'ils se connectent à un serveur de jeux. Leservice collecte également des métriques sur l'état du serveur RealTime et sur l'utilisation des joueurs.

Version10

Amazon GameLift Manuel du développeurComment Serveurs en temps réel gère les sessions de jeu

• Une session de jeu est une instance de votre jeu qui s'exécute sur un serveur RealTime. Les joueurs seconnectent à une session de jeu pour participer au jeu et interagir avec les autres joueurs.

Comment Serveurs en temps réel gère les sessions dejeuGameLift gère les sessions de jeux avec Serveurs en temps réel de la même manière qu'il le fait avec desserveurs de jeu entièrement personnalisés. Les joueurs, à l'aide d'un client de jeu, envoient des demandespour créer de nouvelles sessions de jeu ou pour trouver et rejoindre des sessions de jeu existantes. Laplupart des méthodes pour créer des sessions de jeu, notamment le placement d'une session de jeu et lamise en relation FlexMatch, sont disponibles avec Serveurs en temps réel (le renvoi de correspondancen'est pas encore disponible).

Un serveur RealTime, une fois déployé sur une flotte d'instances d'hébergement, maintient lacommunication avec le service GameLift. Le serveur RealTime serveur démarre une session de jeulorsqu'il y est invité par le service GameLiftet reçoit les données de session de jeu et de joueur disponibles,y compris les données de mise en relation du service. Si votre jeu utilise des sessions de joueur pourréserver des emplacements de jeu ou authentifier des connexions de joueur, le serveur RealTime peutenvoyer une demande de validation au service GameLift lorsque le joueur se connecte. Un serveurRealTime rapporte également son état de santé au service et informe le service GameLift lorsque lesjoueurs se connectent ou se déconnectent, et lorsqu'une session de jeu se termine. Il répond égalementaux invites d'GameLift pour forcer l'arrêt d'une session de jeu. Cette interaction avec le service GameLiftest entièrement intégrée à tous les Serveurs en temps réel.

Vous avez la possibilité d'ajouter une logique personnalisée à la gestion de session de jeu en l'intégrantau script RealTime. Vous pouvez écrire du code pour accéder à des objets spécifiques au serveur, ajouterune logique basée sur les événements à l'aide de rappels ou ajouter une logique basée sur des scénariosautres que des événements, comme un minuteur ou un contrôle de statut. Par exemple, vous pouvezsouhaiter ou accéder à des objets de session de jeu, ou déclencher une action lorsqu'une session de jeucommence ou se termine.

L'interaction entre les clients et serveurs en temps réelAu cours d'une session de jeu, l'interaction entre les clients de jeu se fait par messagerie. Les clients dejeu utilisent les messages pour l'activité d'échange l'état du jeu et les données de jeu pertinentes. Lesclients de jeu envoient des messages au serveur RealTime, qui transmet ensuite les messages entre lesclients de jeu. Les clients de jeu communiquent avec le serveur à l'aide du kit SDK RealTime Client, quidoit être intégré à votre client de jeu. Le kit SDK Client définit un ensemble d'appels d'API synchrones quipermettent aux clients de se connecter à des parties, d'envoyer des messages et de se déconnecter desparties. Il définit également un ensemble de rappels asynchrones, qui peuvent être mis en œuvre sur leclient de jeu et qui permettent au client de répondre à certains événements.

En outre, vous pouvez personnaliser la façon dont les clients et les serveurs interagissent en ajoutantune logique de jeu au script RealTime. Avec une logique de jeu personnalisée, un script RealTime peutimplémenter les rappels pour déclencher des réponses guidées par les événements. Par exemple,lorsqu'un client de jeu informe le serveur qu'une certaine réussite est atteinte, le serveur envoie unmessage à d'autres clients de jeu pour demander une annonce.

Protocole de communication

La communication entre un serveur RealTime et des clients de jeu connectés utilise deux canaux : uneconnexion TCP pour profiter d'un envoi fiable et un canal UDP pour une livraison rapide. Lorsque vouscréez des messages, les clients de jeu choisissent le protocole à utiliser en fonction de la nature dumessage. La livraison de message est définie sur UDP par défaut. Si un canal UDP n'est pas configuré oun'est pas disponible, tous les messages sont envoyés à l'aide de TCP comme solution de secours.

Version11

Amazon GameLift Manuel du développeurPersonnalisation d'un serveur RealTime

Contenu des messages

Le contenu des messages se compose de deux éléments : une opération de code obligatoire (opCode)et une charge utile facultative. L'opCode d'un message identifie un événement de jeu ou une activité dejoueur, tandis que la charge utile fournit des données supplémentaires, en fonction des besoins, liées aucode d'opération. Ces deux éléments sont définis par le développeur, ce qui signifie que vous définissezquelles actions correspondent à quels opCodes et si une charge utile de message est nécessaire. Votreclient de jeu effectue des actions en fonction des opCodes dans les messages qu'il reçoit.

Groupes de joueurs

Les Serveurs en temps réel fournissent des fonctionnalités pour gérer des groupes de joueurs. Tousles joueurs connectés à un jeu sont placés dans un groupe « tous les joueurs » par défaut. De plus, lesdéveloppeurs peuvent configurer des groupes supplémentaires pour leurs jeux et les joueurs peuvent êtremembres de plusieurs groupes à la fois. Les membres du groupe peuvent envoyer des messages à tousles joueurs du groupe ou partager des données de jeu avec le groupe. Une utilisation possible pour lesgroupes consiste à configurer les équipes de joueurs et à gérer la communication de l'équipe.

Serveurs en temps réel avec certificats TLS

Vous pouvez choisir de créer des flottes Serveurs en temps réel avec la génération de certificats TLSactivée. GameLift génère un certificat TLS pour la flotte et crée une entrée DNS pour chaque instancede la flotte. Cela permet à votre jeu d'authentifier la connexion client/serveur et de chiffrer toutes lescommunications client/serveur de jeu. Cette fonctionnalité permet de publier des jeux sur différentes plates-formes, y compris les appareils mobiles, qui nécessitent une sécurité renforcée et une communicationchiffrée. Il permet de protéger vos clients de jeu (et les joueurs) contre les attaques par usurpation deserveur et empêche les acteurs malveillants de pirater ou de surveiller les transmissions de données.Ces services sont fournis via AWS Certificate Manager (ACM) et sont actuellement disponibles sans fraissupplémentaires.

Avec Serveurs en temps réel, l'authentification du serveur et le chiffrement des paquets de données sontdéjà intégrés au service et sont activés lorsque vous activez la génération de certificats TLS. Lorsquele client de jeu essaie de se connecter à un serveur en temps réel, le serveur répond automatiquementavec le certificat TLS, que le client valide. Le chiffrement est géré avec TLS pour la communication TCP(Websockets) et DTLS pour le trafic UDP.

Personnalisation d'un serveur RealTimeDans sa forme la plus basique, un serveur RealTime s'exécute en tant que serveur de relais sans état. Leserveur RealTime transmet des paquets de messages et de données de jeu entre les clients de jeu qui sontconnectés au jeu, mais n'évalue pas les messages, ne traite pas les données ou n'exécute aucune logiquede jeu. Employé de cette manière, chaque client de jeu conserve une vue de l'état du jeu et fournit desmises à jour à d'autres joueurs via le serveur de relais. Chaque client de jeu est responsable de l'intégrationde ces mises à jour et de la conciliation de son propre état de jeu.

Sinon, vous pouvez personnaliser vos serveurs en créant la fonctionnalité de script RealTime. Toutefois, ilexiste de nombreux processus côté serveur que vous pouvez choisir de mettre en œuvre tout en tirant partide la simplicité de la fonctionnalité Serveurs en temps réel. Grâce à la logique de jeu, par exemple, vouspouvez choisir de créer un jeu avec état faisant autorité sur le serveur avec une vue de l'état du jeu.

Un ensemble de rappels côté serveur sont définis pour les scripts RealTime. Implémentez ces rappels pourajouter des fonctionnalités pilotées par les événements à votre serveur. Par exemple, vous pouvez :

• Authentifier un joueur lorsqu'un client de jeu essaie de se connecter au serveur.• Valider le fait qu'un joueur puisse rejoindre un groupe sur demande.• Évaluez le moment où vous souhaitez envoyer des messages à partir d'un joueur ou à un joueur cible,

ou pour effectuer un traitement supplémentaire en réponse.

Version12

Amazon GameLift Manuel du développeurDéployer et mettre à jour les Serveurs en temps réel

• Prenez des mesures, telles que la notification de tous les joueurs, lorsqu'un joueur quitte un groupe ouse déconnecte du serveur.

• Évaluez le contenu des objets de session de jeu ou des objets de message, et utiliser les données.

Déployer et mettre à jour les Serveurs en temps réelServeurs en temps réel est alimenté par les ressources serveur dédiées d'GameLift. Il n'y a aucunedifférence de stabilité et de sécurité fournies. Comme avec tous les serveurs, la latence peut êtreminimisée à l'aide de la mise en relation et des files d'attente GameLift avec Fleet IQ, ce qui optimise leplacement des sessions de jeu en fonction de l'emplacement des joueurs.

Lorsque vous déployez des jeux Serveurs en temps réel avec GameLift, le processus est presque identiqueau déploiement de serveurs de jeu traditionnels sur GameLift. Vous créez des flottes de ressourcesinformatiques et les déployez avec votre script RealTime, qui contient les détails de configuration et unelogique personnalisée facultative. Avec GameLift, vous choisissez le type de flottes à utiliser, gérez lacapacité de la flotte et contrôlez la façon dont les processus serveur de jeux sont démarrés et exécutéssur vos flottes. La description détaillée de l'hébergement de jeux dans Fonctionnement d'un AmazonGameLift (p. 3) représente l'hébergement de jeux avec Serveurs en temps réel ainsi qu'avec desserveurs de jeux personnalisés.

Un avantage Serveurs en temps réel clé est la possibilité de mettre à jour vos scripts à tout moment. Vousn'avez pas besoin de créer une nouvelle flotte pour déployer un script mis à jour. Lorsque vous mettez àjour un script, le nouveau script est propagé à toutes les ressources d'hébergement en quelques minutes.Une fois que le nouveau script est déployé, toutes les nouvelles sessions de jeu créées après ce pointutiliseront la nouvelle version du script (les sessions de jeu existantes continueront d'utiliser leur versiond'origine).

Comment les joueurs se connectent aux JeuxUne session de jeu est une instance de votre jeu qui s'exécute sur Amazon GameLift. Pour jouer à votrejeu, les joueurs peuvent trouver et participer à une session de jeu existante ou créer une session dejeu et y participer. Les joueurs participent en créant une session de joueur pour la session de jeu. Si lasession de jeu est ouverte aux joueurs, c'est-à-dire si elle accepte de nouveaux joueurs et possède unemplacement de joueur ouvert, Amazon GameLift réserve un emplacement pour le joueur et fournit lesinformations de connexion au joueur. —— Le joueur peut alors se connecter à la session de jeu et profiterde l'emplacement réservé.

Pour obtenir des informations détaillées sur la création et la gestion de sessions de jeu et de sessions dejoueur, consultez Ajout d'Amazon GameLift à votre client de jeu (p. 53).

Fonctionnalités d'une session de joueur et d'unesession de jeuAmazon GameLift fournit plusieurs fonctionnalités liées aux sessions de jeu et sessions de joueur :

Hébergement des sessions de jeu sur les meilleures ressourcesdisponibles de plusieurs régionsChoisissez entre plusieurs options lors de la configuration de la façon dont Amazon GameLift sélectionneles ressources pour héberger de nouvelles sessions de jeu. Si vous exécutez plusieurs flottes dansplusieurs régions, vous pouvez configurer des files d'attente de session de jeu qui peuvent placer unenouvelle session de jeu sur n'importe quelle flotte, quelle que soit la région. Cette fonction peut améliorer

Version13

Amazon GameLift Manuel du développeurFonctionnalités d'une session de

joueur et d'une session de jeu

significativement la capacité du service d'Amazon GameLift à équilibrer efficacement l'utilisation desressources et à répondre aux modifications de demande de joueur, à la diminution de capacité, auxévénements de panne et autres problèmes. En conséquence, à l'aide des files d'attente, vous pouvezréduire le temps manuel passé à surveiller et à équilibrer les ressources. Vous pouvez gérer les filesd'attente et suivre les métriques des performances des files d'attente dans la console Amazon GameLift.

Grâce à la fonction des files d'attente, vous avez la possibilité de placer des sessions de jeu en fonctiondes informations de latence des joueurs. Cette fonction est particulièrement efficace lors de la prise encharge d'un service de mise en relation. Les demandes concernant une nouvelle session de jeu peuventégalement demander de nouvelles sessions de joueur pour un ou plusieurs joueurs. Si vous incluez lesdonnées de latence pour chaque joueur par région, Amazon GameLift peut choisir une flotte dans unerégion qui offre la meilleure expérience possible pour tous les joueurs.

Contrôle de l'accès des joueurs aux sessions de jeuDéfinissez une session de jeu pour accepter ou refuser les demandes de participation de nouveauxjoueurs, quel que soit le nombre de joueurs actuellement connectés. Vous pouvez utiliser cettefonctionnalité pour activer des sessions privées, limiter l'accès pour la résolution des problèmes dépannageou autres, etc..

Ajout de données de jeux et de joueurs personnaliséesVous pouvez ajouter des données personnalisées aux objets de session de jeu et de joueur, quicontiennent tous les paramètres et métadonnées d'une session. Les données personnalisées sontstockées avec Amazon GameLift et peuvent être récupérées par d'autres composants en fonction de vosbesoins. Le service Amazon GameLift transmet les données de session de jeu à un serveur de jeux lors dulancement d'une nouvelle session de jeu, et transmet les données de session de joueur au serveur de jeuxlorsqu'un joueur se connecte à la session de jeu. Les données de jeu et de joueur personnalisées ne sontpas utilisées par Amazon GameLift ; elles peuvent être formatés en fonction des besoins de votre client dejeu, serveur de jeux ou d'autres services de jeux.

Les données de jeu peuvent être utiles pour différentes raisons. Par exemple, lorsque vous faitescorrespondre des joueurs potentiels à des sessions de jeu, votre jeu peut utiliser des propriétés de jeu pouraméliorer l'algorithme de mise en correspondance des joueurs ou pour aider les joueurs à faire un choixdans une liste des sessions de jeu. Vous pouvez sinon utiliser les propriétés de jeu pour transmettre desinformations dont un serveur de jeux a besoin lors de la configuration d'une nouvelle session de jeu, parexemple un mode ou une carte de jeu.

Les données des utilisateurs sont également utilisées dans de nombreux scénarios. Par exemple,un service de mise en relation peut utiliser les données des joueurs pour sélectionner une meilleurecorrespondance ou le placement d'une équipe. Un serveur de jeux peut personnaliser l'expérience d'unjoueur en fonction de son adhésion à des associations.

Filtrage et tri des sessions de jeu disponiblesUtilisez la fonction de recherche et de tri de session pour trouver la meilleure correspondance pour unjoueur potentiel ou autorisez les joueurs à parcourir la liste des sessions de jeu disponibles. Grâce àcette fonctionnalité, vous pouvez diriger les joueurs vers des sessions plus susceptibles de produire uneexpérience positive. Par exemple, si votre jeu nécessite un nombre minimum de joueurs, la redirectiondes nouveaux joueurs vers des parties presque pleine minimisera le temps d'attente pour tous les joueurs.Sinon, vous souhaiterez probablement masquer les sessions presque terminées. La recherche de sessionpeut être très utile pour mettre en œuvre une fonctionnalité « join now » basée sur une expression derecherche et de tri correctement formulée pour proposer rapidement aux joueurs des expériences dejeu positives. Utilisez les fonctions de recherche et de tri de session pour trouver des sessions de jeuen fonction de caractéristiques telles que l'âge de session, les emplacements de joueur disponibles,le nombre de joueurs en cours, le nombre de joueurs maximum autorisés et les données de sessionde jeu personnalisées. Vous pouvez également rechercher et trier selon vos propres données de jeupersonnalisées.

Version14

Amazon GameLift Manuel du développeurFonctionnement d'GameLift FlexMatch

Suivi des données d'utilisation de jeu et des données d'utilisationdes joueursConfigurez Amazon GameLift afin qu'il stocke automatiquement les journaux des sessions de jeuterminées. Configurez le stockage des journaux lors de l'intégration d'Amazon GameLift dans vos serveursde jeux. Vous pouvez accéder aux journaux stockés en les téléchargeant à l'aide de la console AmazonGameLift ou par programmation avec le kit AWS SDK pour Amazon GameLift.

Utilisez la console Amazon GameLift pour afficher des informations détaillées sur les sessions de jeu, ycompris les métadonnées et paramètres de session ainsi que les données de session de joueur. Pourchaque session de jeu, vous pouvez afficher une liste des sessions de joueur ainsi que les temps totaux dejeu. Vous pouvez aussi afficher les données et graphiques de métriques qui suivent le nombre de sessionsde jeu et de sessions de joueur actives au fil du temps. Pour plus d'informations, consultez Affichage desdonnées sur les sessions de jeu et les sessions de joueur (p. 199) et Métriques (p. 196).

Fonctionnement d'Amazon GameLift FlexMatchCette rubrique offre une vue d'ensemble du système de mise en relation FlexMatch, qui est disponible dansle cadre des solutions GameLift gérées. Cette rubrique décrit les principales fonctions, les composants et lefonctionnement du processus de mise en relation. Pour obtenir une aide détaillée sur l'ajout de FlexMatch àvotre jeu, y compris sur la façon de configurer un matchmaker et de personnaliser une mise en relation dejoueurs, consultez Ajout en cours de mise en relation FlexMatch (p. 77).

GameLift FlexMatch est un service personnalisable de mise en relation. Il vous propose des outils flexiblesqui vous permettent de gérer l'intégralité de l'expérience de mise en relation d'une manière qui correspondle mieux à votre jeu. Utilisez FlexMatch pour constituer des équipes pour les parties de jeu, sélectionner lesjoueurs compatibles et trouver les meilleures ressources d'hébergement disponibles pour une expériencejoueur optimale. Vous pouvez également utiliser le remplissage FlexMatch pour trouver de nouveauxjoueurs pour les jeux existants. De la sorte, les jeux rassemblent les joueurs qualifiés nécessaires tout aulong de la durée de la session.

Avec FlexMatch, vous pouvez créer et exécuter autant de matchmakers que vous le souhaitez pourcorrespondre à vos modes de jeux et à vos joueurs. Par exemple, il est probable que vous utilisiez desmatchmakers distincts pour créer des équipes pour une partie gratuite pour tous et pour une rencontre àhuis clos.

Fonctionnalités principales de FlexMatch• Personnalisation de la mise en relation de joueurs. Concevez et développez les types d'expériences

multijoueur que vos joueurs trouveront les plus attrayantes. Pour chaque mode de jeu, définissezla structure de l'équipe et configurez les autres attributs du jeu. Créez un ensemble de règlespersonnalisées pour évaluer les attributs des joueurs (tels que le niveau de compétence ou le rôle) etformez les meilleures rencontres de joueurs possibles pour un jeu. Utilisez ces règles pour regrouperles joueurs dans le cadre de nouvelles rencontres ou pour trouver des joueurs afin de remplir lesemplacements ouverts de rencontres existantes (« remplissage de rencontre »). Voir plus de détails surla mise en relation personnalisée dans Exemples FlexMatch d'ensembles de règles (p. 169).

• Créez des parties à beaucoup de joueurs. FlexMatch permet de créer des parties comprenant de 41 à200 joueurs à l'aide d'un algorithme qui simplifie le processus de mise en relation des joueurs. Lorsquevous créez des parties à beaucoup de joueurs, vous pouvez opter pour la création de parties réunissanten priorité des joueurs similaires ou la création de parties où tous les joueurs ont une expérienceoptimale en matière de latence.

• Obtention de l'acceptation des joueurs. Demandez à tous les joueurs d'accepter une mise en relationproposée avant de commencer. Si cette fonction est activée, FlexMatch attend que tous les joueursaffectés à une mise en relation l'aient acceptée avant que la mise en relation ne commence.

Version15

Amazon GameLift Manuel du développeurComposants de FlexMatch

Prise en charge de parties entre joueurs. Générez des rencontres pour un groupe de joueurs quisouhaitent jouer ensemble dans la même équipe. Trouvez d'autres joueurs pour remplir la rencontreselon vos besoins.

• Mise en relation de joueurs en fonction de la latence. Utilisez les informations sur la latence des joueurspour vous assurer que les joueurs associés ont des temps de réponse similaires. Cette fonction empêchedes disparités du gameplay pouvant conférer un avantage non justifié à certains joueurs. Cette fonctionest particulièrement utile lors de la création de rencontre couvrant plusieurs zones géographiques.

• Assouplissement des règles de mise en relation des joueurs dans le temps. Atteignez le bon équilibreentre la création des meilleures rencontres entre les joueurs et l'obtention rapide de joueurs dans lesrencontres adéquates. Vous décidez où et quand assouplir des règles strictes d'association afin d'obtenirdes joueurs pour les rencontres dans un délai d'attente minimal.

• Recherche des meilleures ressources d'hébergement. Utilisez les informations du jeu et du joueur poursélectionner les meilleure ressources disponibles afin d'héberger la rencontre pour une expérience degameplay optimale.

• Maintien du remplissage des jeux avec des joueurs mis en relation. Utilisez la fonction de remplissageFlexMatch pour remplir les emplacements dédiés aux joueurs vides avec de nouveaux joueurs qui secorrespondent bien tout au long de la durée de vie de la session de jeu. Vous pouvez choisir d'activer leremplissage automatique ou ajouter du code à votre jeu pour gérer manuellement cette fonctionnalité.

Composants de FlexMatchAmazon GameLift FlexMatch nécessite le fonctionnement simultané de ces trois composants clés :

• Mécanismes pour déclencher la mise en relation de joueurs. Un mécanisme détermine quand lancer lamise en relation des joueurs. Un deuxième mécanisme (facultatif) détermine quand trouver de nouveauxjoueurs pour combler les emplacements vides d'une partie existante (remplissage). Les demandes demise en relation et de remplissage de rencontre sont transmises à un matchmaker pour le traitement.

• Matchmaker FlexMatch pour évaluer les joueurs et créer des rencontres. Un matchmaker élaboreleurs meilleures rencontres possibles entre les joueurs à partir des demandes reçues. Il dispose d'unensemble de règles définissant la structure d'équipe d'une rencontre et configurant le critères à utiliserdans l'évaluation des joueurs pour une rencontre. Un même jeu peut disposer de plusieurs matchmaker,chacun élaborant un différent type de rencontre.

• File d'attente d'une session de jeu pour obtenir une place dans une nouvelle rencontre. Une file d'attented'une session de jeu trouve les ressources de calcul disponibles pour héberger une rencontre. Elledétermine où (dans quelles régions) chercher les ressources et comment sélectionner le meilleur hôtedisponible pour chaque rencontre.

Les sections suivantes détaillent le procédé suivi par la mise en relation pour former de nouvellesrencontres de jeu ou pour trouver de nouveaux joueurs pour des rencontres de jeu existantes.

Processus de mise en relationVoici la manière dont FlexMatch traite les demandes de nouvelles rencontres de jeu. Cette descriptionsuppose qu'un service de jeu côté client lance des demandes de mise en relation et suit l'état du ticket demise en relation.

1. Demander une mise en relation. Les joueurs accomplissent certaines actions dans votre jeu. Cesactions déclenchent la mise en relation, par exemple en cliquant sur le bouton « Rejoindre maintenant »ou lorsqu'un groupe de joueurs forme une partie. Votre jeu lance une demande de mise en relation,identifiant chaque matchmaker à utiliser et incluant un ou plusieurs joueurs à mettre en relation. Lademande comprend toutes les informations du joueur telles que le niveau de compétence et lespréférences. Ces informations sont nécessaires au matchmaker pour élaborer des rencontres. Chaque

Version16

Amazon GameLift Manuel du développeurProcessus de mise en relation

demande reçoit un ID de ticket de mise en relation, utilisé par votre jeu pour suivre l'état de la demandeet agir en conséquence.

2. Découvrir des rencontres potentielles. Tous les tickets de mise en relation sont transmis au matchmakerspécifié et placés dans son groupe de ticket pour le traitement. Un ticket reste dans le pool de ticketjusqu'à ce qu'il soit associé ou qu'il ait atteint la limite de temps maximum du matchmaker.

Pour trouver des joueurs compatibles pour une partie classique (pas pour les parties à beaucoup dejoueurs), le matchmaker passe continuellement au crible le pool de tickets. À chaque transmission,le matchmaker démarre par le ticket le plus ancien du groupe et y compare les autres tickets pourtrouver les meilleures correspondances. L'ensemble de règles d'un matchmaker détermine (1) le nombred'équipes à créer pour une rencontre, (2) le nombre de joueurs à attribuer à chaque équipe et (3) lemode d'évaluation de chaque joueur potentiel. Les règles peuvent définir des exigences pour chaquejoueur, équipe ou rencontre. Par exemple, une règle peut nécessite que tous les joueurs correspondantsaient un certain talent, ou encore qu'au moins un joueur d'une équipe joue un certain personnage.Une règle courante nécessite que tous les joueurs d'une rencontre aient des scores de compétencesimilaires.

Pour les parties à beaucoup de joueurs, le processus est légèrement différent. Au lieu d'évaluer chaquejoueur par rapport à un ensemble de règles, FlexMatch compare les tickets disponibles par rapport àun seul attribut et regroupe les joueurs qui ont les mêmes valeurs d'attribut. Il applique également desexigences de latence. Pour les parties à beaucoup de joueurs, vous avez le choix entre la création departies réunissant en priorité des joueurs similaires ou la création de parties où tous les joueurs ont uneexpérience optimale en matière de latence. Une fois qu'une partie initiale est trouvée, FlexMatch effectueune série de tests pour s’assurer que la dernière partie est la meilleure solution.

Lorsque le matchmaker évalue un ticket, il décide de son succès ou de son échec complet En cas detickets relatifs à plusieurs joueurs, le matchmaker suppose que ces joueurs souhaitent jouer ensembleet tente de les placer dans la même partie. Cela signifie que pour toutes les potentielles rencontres, tousles joueurs d'un ticket doivent être acceptables. Si l'un des joueurs n'entre pas dans le cadre d'une règle,le ticket entier est considéré comme contraire à la rencontre. Les tickets échoués restent dans le groupede ticket et sont évalués de nouveau au cours de la transmission suivante. Une fois qu'une rencontrepotentielle est complète, les états de tous les tickets de la rencontre sont mis à jour.

3. Obtention de l'acceptation des joueurs. Si le matchmaker nécessite que les joueurs acceptent unepotentielle rencontre, FlexMatch ne peut poursuivre la rencontre que lorsque tous les joueurs ontaccepté. L'état du ticket de mise en relation est modifié pour indiquer que l'acceptation est requise, cequi envoie une invite à votre jeu de demander les acceptations de tous les joueurs dans chaque ticketcorrespondant.

Les joueurs peuvent choisir d'accepter ou de rejeter un potentiel rencontre. Votre jeu recueille lesréponses joueur et les transmet à FlexMatch. Afin de continuer, tous les joueurs d'une rencontrepotentielle doivent accepter la rencontre dans un délai imparti. Si un joueur refuse la mise en relationou échoue à répondre avant la limite de temps, le matchmaker supprime la mise en relation potentielle.Les tickets des joueurs qui ont accepté la mise en relation sont renvoyés vers le pool de ticket dumatchmaker ; les tickets des joueurs qui n'ont pas accepté la mise en relation passent à un état d'échecet ne sont plus traités.

4. Trouver des ressources pour héberger la rencontre. Une fois la rencontre potentielle effectuéeet acceptée, FlexMatch tente de la placer dans les ressources d'hébergement disponibles. Lematchmaker est configuré pour utiliser une file d'attente de sessions de jeu spécifique et il transmet lacorrespondance potentielle au placement dans cette file d'attente. Pour héberger la rencontre, la filed'attente utilise un ensemble de règles pour parcourir des régions et parcs afin de trouver le meilleurprocessus serveur disponible. Si la demande de mise en relation d'origine contenait les données delatence du joueur, la file d'attente utilise ces informations pour trouver les ressources offrant la latence laplus faible et l'expérience de gameplay la plus cohérente pour les joueurs de la rencontre.

Une fois le processus serveur disponible localisé, Amazon GameLift crée un enregistrement de lasession de jeu avec les propriétés du jeu et les données du matchmaker, notamment la structure et lestailles de l'équipe, les affectations du joueur et toute caractéristique de joueur pertinente.

Version17

Amazon GameLift Manuel du développeurProcessus de remplissage

5. Démarrer une nouvelle session de jeu. Tout comme lors du démarrage de nouvelles sessions de jeu,Amazon GameLift envoie au processus serveur une demande de démarrage, ainsi que les informationsrelatives à la session de jeu et au matchmaker. Le processus serveur utilise ces informations pourdémarrer une nouvelle session de jeu pour un jeu correspondant. Lorsque la session de jeu est prête àaccepter des joueurs, le processus serveur en informe Amazon GameLift.

6. Connecter des joueurs à la nouvelle session de jeu. Lorsque la session de jeu est prête pour les joueurs,Amazon GameLift crée de nouvelles sessions de joueur pour chaque joueur de la rencontre. Pas lasuite, il met à jour tous les tickets de mise en relation en modifiant l'état du ticket qui indique alors lesuccès et en ajoutant les informations de connexion pour tous les joueurs. Ce changement d'état duticket invite votre jeu à relayer les informations de connexion aux clients du jeu. Les joueurs peuventalors se joindre au jeu et réclamer leurs emplacements dans la rencontre et leurs affectations d'équipe.

Processus de remplissageVoici comment FlexMatch trouve de nouveaux joueurs pour une rencontre existante. Dans la mesure où leremplissage de rencontre nécessite des informations à jour sur la disponibilité d'un emplacement de joueurdans des sessions de jeu, nous recommandons d'initialiser des demandes de remplissage de rencontredepuis le serveur de jeu. Il existe une autre option consistant à utiliser un service de jeu côté client quisuit la session de jeu et l'activité du joueur, par exemple une service de référentiel de session. Pour ensavoir plus sur l'ajout de fonctionnalité de remplissage de rencontre à votre jeu, consultez Renvoi de jeuxexistants avecFlexMatch (p. 85).

Si le remplissage automatique est activé dans la configuration de la mise en relation, le processus estsimilaire. La seule différence est que la demande de remplissage initiale est généré par GameLift au lieude votre code. Les demandes de remplissage automatique sont déclenchées lorsqu'une place est ouvertedans un session de jeu.

1. Demander une mise en relation de remplissage. Un jeu correspondant présente des emplacementsjoueur vides devant être remplis. Votre jeu initialiser une demande de remplissage en identifiant lematchmaker à utiliser et en décrivant les joueurs actuels dans la session de jeu. Chaque demandedispose d'un ID de ticket de mise en relation, utilisé par votre jeu pour suivre l'état de la demande et agiren conséquence. Avec le remplissage automatique, l’ID de ce ticket est ajouté aux données de mise enrelation de la session de jeu.

2. Découvrir des rencontres potentielles. Les tickets de mise en relation destinés aux remplissages sonttransmis au matchmaker spécifié et placé dans le même groupe que les tickets destiné aux nouvellesrencontres. Pour les parties à beaucoup de joueurs uniquement, le remplissage des parties existantes ala priorité sur les nouvelles parties.

Le matchmaker évalue les tickets et les joueurs de la même manière, que les tickets correspondentà de nouveaux joueurs ou une demande de remplissage. Une rencontre potentielle ne pouvant pasprésenter plus d'un ticket de remplissage constitue la seule exception. Même lorsque les règles dumatchmaker permettent à une rencontre de se produire avec des emplacements de joueur vides, unticket de remplissage doit correspondre à au moins un autre ticket afin d'arriver à terme avec succès.Une fois qu'une rencontre potentielle est complète, l'état de tous les tickets de la rencontre est mis àjour.

3. Obtention de l'acceptation des joueurs. Si l'acceptation est requise, seuls les nouveaux joueurs doiventaccepter une rencontre de remplissage. Cette étape est traitée de la même façon que les demandes demise en relation. Les joueurs actuels n'ont pas besoin d'accepter une rencontre dans laquelle ils sontdéjà en cours de jeu. De ce fait, bien que l'état du ticket d'une demande de remplissage indique quel'acceptation est requise, votre jeu ne nécessite aucune action.

Si les nouveaux joueurs proposés échouent à accepter la rencontre dans la limite de temps, la rencontrepotentielle est abandonnées et aucun nouveau joueur n'est ajouté à la rencontre existante. Dans cettesituation, l'état de la demande de remplissage revient au groupe de ticket pour le traitement.

Version18

Amazon GameLift Manuel du développeurArchitecture de jeu avec solution GameLift gérée

4. Mettre à jour une session de jeu existante avec de nouvelles données de rencontre. Lorsqu'unerencontre de remplissage est achevée avec succès, une nouvelle session de jeu n'est pas nécessaire.Au lieu de cela, Amazon GameLift met à jour les données de la mise en relation pour la session de jeuexistante, en ajoutant les nouveaux joueurs et les affectations de l'équipe. Amazon GameLift envoie lesinformations de session de jeu mises à jour au processus serveur qui héberge le jeu existant.

5. Connecter de nouveaux joueurs à la session de jeu existante. Amazon GameLift crée des sessionsde joueur pour les nouveaux joueurs et met à jour les tickets de mise en relation avec les informationsd'état, de sessions de joueur et de connexion actuelles. Votre service de jeu client suit l'état du ticketdes nouveaux joueurs et relaie les informations de connexion aux clients du jeu. Les joueurs peuventdésormais rejoindre le jeu existant et réclamer leur emplacement de joueur.

Architecture de jeu avec solution GameLift géréeLe schéma ci-dessous illustre les principaux composants d'une architecture de jeu hébergée à l'aide de lasolution GameLift gérée.

Voici la description des principaux composants.

Clients de jeu

Pour joindre un jeu hébergé sur GameLift, votre client de jeu doit d'abord trouver une session de jeudisponible. Le client de jeu recherche les sessions de jeu existantes, demande une mise en relation ou

Version19

Amazon GameLift Manuel du développeurArchitecture de jeu avec solution GameLift gérée

commence une nouvelle session de jeu en communiquant avec le service GameLift. Cette communicationest effectuée par le biais d'un service de client backend pour aider les propriétaires à conserver le contrôlesécurisé de leurs serveurs de jeux et de leurs ressources d'hébergement. Le service client effectue lesdemandes au service GameLift et reçoit en réponse des informations sur des sessions de jeu, y comprisles détails de connexion qu'il relaie vers le client de jeu. Le client de jeu utilise ensuite ces informations,avec le kit SDK du client en temps réel, pour se connecter directement au serveur de jeux et rejoindre lapartie. La flèche verte représente la connexion directe entre le client et le serveur de jeux pendant uneséquence de jeu.

Services du client

Un service backend du client gère la communication entre les clients de jeu et le service GameLift enappelant les API de service GameLift dans le kit SDK AWS. Les services client peuvent également êtreutilisés pour d'autres tâches spécifiques du jeu telles que l'authentification et l'autorisation des joueurs,l'inventaire ou le contrôle de devise. Par exemple, lorsqu'un joueur rejoint un jeu, votre client de jeu peutcommencer par appeler un service d'authentification pour vérifier l'identité du joueur, puis envoyer unedemande d'emplacement de joueur au service GameLift. Les données pertinentes, telles que les détails deconnexion, sont transmises au client de jeu.

Services externes

Votre jeu peut s'appuyer sur un service externe, par exemple pour valider une inscription. Comme illustrédans le schéma d'architecture, les informations provenant d'un service externe peuvent être transmises àvos serveurs de jeux (via un service de client et le service GameLift) sans passer par le client de jeu.

Serveurs de jeux

Votre logiciel de serveur de jeux est chargé dans le service GameLift et est déployé sur des machinesd'hébergement pour héberger des sessions de jeu et accepter les connexions de joueurs. Les serveursde jeux communiquent avec le service GameLift en utilisant les kits SDK GameLift Server, en échangeantdes demandes de démarrage de nouvelles sessions, en validant les joueurs nouvellement connectés, ainsiqu'en indiquant l'état des sessions de jeu, des connexions de joueurs et des ressources disponibles. Lesclients de jeu se connectent directement à un serveur de jeux après la réception des détails de connexiondu service GameLift.

Service GameLift

Le service GameLift est le service principal qui déploie et gère les flottes de ressources pour hébergervos serveurs de jeux. Il coordonne la façon dont les sessions de jeu sont placées dans vos ressourcesdisponibles, démarre et arrête les sessions de jeu, et surveille l'état et l'activité du serveur de jeux afinde garantir la disponibilité du jeu à mesure que le trafic de joueurs fluctue. Lors de la configuration et dela gestion des ressources d'hébergement, les propriétaires de jeux utilisent les API de service GameLiftdans le kit SDK AWS et l'interface de ligne de commande pour charger des builds de serveur de jeux,créer et configurer des flottes, et gérer la capacité de ces dernières. Les services du client lancent denouvelles sessions de jeux, demandent la mise en relation et attribuent les joueurs à des sessions dejeu en appelant les API du service GameLift dans le kit SDK AWS. Les serveurs de jeux déployés dansdes flottes GameLift utilisent le kit SDK GameLift Server pour maintenir la communication avec le serviceGameLift afin de démarrer et d'arrêter les sessions de jeu, rendre compte de l'état du serveur, échangerdes données de jeu et de joueurs selon vos besoins, etc.

Outils de gestion d'hébergement

Les outils pour développeurs GameLift du kit SDK AWS vous offrent de nombreuses façons de configurervos ressources d'hébergement de jeux, mettre à l'échelle la capacité en fonction de la demande desjoueurs et surveiller l'état actuel des ressources, suivre les métriques de performance des jeux ainsi quel'activité des jeux et des joueurs. En outre, vous pouvez accéder à distance à n'importe quel serveur de jeuà des fins de dépannage.

Version20

Amazon GameLift Manuel du développeurArchitecture de jeu avec Serveurs en temps réel

Architecture de jeu avec Serveurs en temps réelLe schéma ci-dessous illustre les principaux composants d'une architecture de jeu hébergée à l'aide de lasolution GameLift gérée avec Serveurs en temps réel.

Voici la description des principaux composants :

Clients de jeu

Pour joindre un jeu hébergé sur GameLift, votre client de jeu doit d'abord trouver une session dejeu disponible. Le client de jeu recherche les sessions de jeu existantes, demande une mise enrelation ou commence une nouvelle session de jeu en communiquant avec le service GameLift. Cettecommunication est effectuée par le biais d'un service de client backend pour aider les propriétairesà conserver le contrôle sécurisé de leurs serveurs de jeux et de leurs ressources d'hébergement. Leservice client effectue les demandes au service GameLift et reçoit en réponse des informations surdes sessions de jeu, y compris les détails de connexion que le client de service relaie vers le client dejeu. Le client de jeu utilise ensuite ces informations, avec le kit SDK du client en temps réel, pour seconnecter directement au serveur de jeux. Une fois la connexion établie, le client de jeu peut rejoindrele jeu et échanger des mises à jour de l'état du jeu avec d'autres joueurs dans le jeu. La flèche vertereprésente la connexion directe entre le client et le serveur de jeux pendant une séquence de jeu.

Version21

Amazon GameLift Manuel du développeurArchitecture de jeu avec Serveurs en temps réel

Services du client

Un service backend du client gère la communication entre les clients de jeu et le service GameLift enappelant les API de service GameLift dans le kit SDK AWS. Les services client peuvent également êtreutilisés pour d'autres tâches spécifiques du jeu telles que l'authentification et l'autorisation des joueurs,l'inventaire ou le contrôle de devise. Par exemple, lorsqu'un joueur rejoint un jeu, votre client de jeupeut commencer par appeler un client d'authentification pour vérifier l'identité du joueur, puis envoyerune demande de session de jeu au service GameLift. Les informations utiles que le service client reçoità partir du service GameLift, telles que les détails de connexion, sont transmises au client de jeu.

Services externes

Votre jeu peut s'appuyer sur un service externe, par exemple pour valider une inscription. Commeillustré dans le schéma d'architecture, les informations provenant d'un service externe peuvent êtretransmises à vos serveurs de jeux (via un service de client et le service GameLift) sans passer par leclient de jeu.

Serveurs en temps réel

Pour héberger des sessions de jeu, vous créez une flotte de Serveurs en temps réel configuréepour votre jeu. Les serveurs RealTime prennent la place d'un véritable serveur de jeux intégréà part entière ; ils exécutent un script que vous personnalisez pour votre jeu et le chargent dansGameLift. Les serveurs RealTime effectuent le suivi des connexions de joueur à une session de jeu ettransmettent les données de jeu entre les joueurs afin de maintenir la synchronisation de l'état de jeude chaque joueur. Ils communiquent également avec le service GameLift pour démarrer de nouvellessessions de jeu, valider les joueurs nouvellement connectés, ainsi que pour indiquer l'état des sessionsde jeu, des connexions de joueur et des ressources disponibles. Lorsqu'il rejoint un jeu, un client de jeuse connecte directement à un serveur RealTime après avoir reçu des détails de connexion à partir duservice GameLift.

Service GameLift

Le service GameLift est le service principal qui déploie et gère les flottes de ressources pour hébergervos serveurs RealTime. Il coordonne la façon dont les sessions de jeu sont placées dans vosressources disponibles, démarre et arrête les sessions de jeu, et effectue le suivi de l'état et del'activité du serveur de jeux afin de garantir la disponibilité du jeu à mesure que le trafic de joueurfluctue. Lors de la configuration et de la gestion des ressources d'hébergement, les propriétaires dejeux utilisent les API de service GameLift dans le kit SDK AWS et l'interface de ligne de commandepour charger des builds de serveur de jeux et des scripts, pour créer et configurer des flottes et gérerla capacité de ces dernières. Les services du client lancent de nouvelles sessions de jeux, demandentla mise en relation et attribuent les joueurs à des sessions de jeu en appelant les API du serviceGameLift dans le kit SDK AWS.

Outils de gestion d'hébergement

Les outils pour développeurs GameLift du kit SDK AWS vous offrent de nombreuses façons deconfigurer vos ressources d'hébergement de jeux, mettre à l'échelle la capacité en fonction de lademande des joueurs et surveiller l'état actuel des ressources, suivre les métriques de performancedes jeux ainsi que l'activité des jeux et des joueurs. En outre, vous pouvez accéder à distance àn'importe quel serveur de jeu à des fins de dépannage.

Version22

Amazon GameLift Manuel du développeurConfiguration d'un compte AWS

ConfigurationDans les rubriques de cette section, trouvez de l'aide pour configurer votre compte AWS et le serviceGameLift, ainsi que pour obtenir les outils nécessaires pour utiliser GameLift pour héberger vos jeuxmultijoueur.

Conseil

Informez-vous sur les façons d'explorer les fonctions Amazon GameLift, en particulier Serveurs entemps réel, à l'aide des exemples de jeux. (p. 32).

Rubriques• Configuration d'un compte AWS (p. 23)• Configuration d'un rôle pour lGameLift'accès (p. 26)• GameLift SDKs (p. 27)• Outils et ressources (p. 29)• Configuration des alertes de facturation AWS (p. 30)• Utilisation d'Amazon GameLift dans les régions AWS (p. 31)

Configuration d'un compte AWSAmazon GameLift est un service AWS. Vous devez disposer d'un compte AWS pour pouvoir utiliserAmazon GameLift. La création d'un compte AWS est gratuite.

Pour plus d'informations sur ce que vous pouvez faire avec un compte AWS, consultez Mise en route avecAWS.

Configuration de votre compte pour Amazon GameLift

1. Obtenez un compte. Ouvrez Amazon Web Services et choisissez Sign In to the Console (Se connecterà la console). Suivez les invites afin de créer un nouveau compte ou de vous connecter à un compteexistant.

2. Configurez les groupes d'utilisateurs et les autorisations d'accès. Ouvrez la console du service AWSIdentity and Access Management (IAM) et suivez ces étapes pour définir un ensemble d'utilisateurs oudes groupes d'utilisateurs et leur attribuer des autorisations d'accès. Les autorisations sont étendues àun utilisateur ou à un groupe d'utilisateurs en associant une stratégie IAM, qui spécifie l'ensemble desservices et des actions AWS auquel un utilisateur doit pouvoir accéder. Pour obtenir des instructionsdétaillées sur l'utilisation de la console (ou de l'interface de ligne de commande AWS ou d'autresoutils) pour configurer vos groupes d'utilisateurs, consultez Création d'utilisateurs IAM.

a. Créer un utilisateur ou un groupe d'utilisateurs administratif. Les utilisateurs administratifs incluentles personnes qui gèrent les ressources Amazon GameLift essentielles, telles que les versionsde génération et les flottes. Pour définir des autorisations, vous devez créer intégralement votrepropre stratégie. Cet exemple (p. 24) illustre une stratégie administrateur pour les servicesAmazon GameLift.

b. Créer un utilisateur joueur. Un utilisateur joueur représente votre client/vos clients de jeu. Ilpermet d'accéder à la fonctionnalité client Amazon GameLift, notamment pour l'acquisition desinformations de sessions de jeu et la participation de joueurs à des jeux. Votre client de jeudoit utiliser les informations d'identification de l'utilisateur joueur lorsqu'il communique avec leservice Amazon GameLift. Pour définir des autorisations, vous devez créer intégralement votre

Version23

Amazon GameLift Manuel du développeurExemples de stratégie IAM

propre stratégie. Cet exemple (p. 24) illustre une stratégie de joueur pour les services AmazonGameLift.

Exemples de stratégies IAM pour GameLiftVous pouvez utiliser les exemples suivants pour créer des stratégies en ligne et ajouter les autorisationsappropriées pour vos utilisateurs ou groupes d'utilisateurs IAM.

Si vous utilisez GameLift FleetIQ comme solution autonome, veuillez consulter Configurez votre compteAWS pour GameLift FleetIQ (p. 229).

Exemples de stratégies simples pour les administrateursCes exemples de stratégie illustrent comment fournir un accès administratif complet à un utilisateur.

Stratégie pour les autorisations d'GameLiftaccès aux ressources

L'exemple de stratégie suivant couvre l'accès à toutes les ressources liées à (flottes, files d'attente,sessions de jeu, matchmakers, etc.).GameLift Tous les utilisateurs qui gèrent ou affichent ces ressourcesont besoin de ce type de stratégie d'autorisations.

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

Stratégie pour les GameLift ressources et PassRole les autorisations

Cet exemple de stratégie fournit un accès aux ressources liées à comme ci-dessus.GameLift Elle permetégalement à l'utilisateur de transmettre un rôle de service IAM à GameLift . Les utilisateurs nPassRole'ontpas tous besoin d'avoir l'autorisation d'accéder aux ressources d'autres services en votre nom. Elle estutilisée pour donner la possibilité GameLift limitée d'accéder en votre nom. Par exemple, vous avezbesoin de cette autorisation lorsque vous appelez CreateBuild avec un rôle IAM qui permet GameLift àd'accéder à vos fichiers de génération dans un compartiment S3. Pour plus d'informations sur PassRole ,consultez la IAM Guide de l'utilisateur rubrique IAM : Transmettez un rôle IAM à un service AWSspécifique.

{"Version": "2012-10-17","Statement":[ { "Effect": "Allow", "Action": "gamelift:*", "Resource": "*" }, { "Effect": "Allow", "Action": "iam:PassRole", "Resource": "*", "Condition": { "StringEquals": {"iam:PassedToService": "gamelift.amazonaws.com"} } }]

Version24

Amazon GameLift Manuel du développeurExemples de stratégie IAM

}

Exemples de stratégie simple pour les joueursLes exemples de stratégie suivants illustrent comment activer les clients de jeu et/ou les services de clientde jeu avec la fonctionnalité permettant aux joueurs de participer aux sessions de jeu. Ces exemplescouvrent les scénarios clés que les jeux peuvent utiliser pour démarrer de nouvelles sessions de jeu etaffecter des joueurs aux emplacements disponibles.

Stratégie pour le placement de sessions de jeu

Cet exemple de stratégie présente un service de client de jeu qui utilise des files d'attente et desplacements de session de jeu pour démarrer de nouvelles sessions de jeu. Les joueurs peuvent êtreajoutés à une session de jeu soit dans la demande de placement initiale, soit par la création de nouvellessessions de joueur pour une session de jeu existante.

{"Version": "2012-10-17","Statement": { "SID": "PlayerPermissionsForGameSessionPlacements", "Effect": "Allow", "Action": [ "gamelift:StartGameSessionPlacement", "gamelift:DescribeGameSessionPlacement", "gamelift:StopGameSessionPlacement", "gamelift:CreatePlayerSession", "gamelift:CreatePlayerSessions", "gamelift:DescribeGameSessions" ], "Resource": "*" }}

Stratégie de mise en relation

Cet exemple de stratégie présente un client de jeu ou un service client qui utilise la mise en relationFlexMatch GameLift. Les joueurs peuvent être mis en correspondance et placés dans une nouvelle sessionde jeu ou ajoutés à une session de jeu existante via le processus de remplissage.

{"Version": "2012-10-17","Statement": { "SID": "PlayerPermissionsForGameSessionMatchmaking", "Effect": "Allow", "Action": [ "gamelift:StartMatchmaking", "gamelift:DescribeMatchmaking", "gamelift:StopMatchmaking", "gamelift:AcceptMatch", "gamelift:StartMatchBackfill", "gamelift:DescribeGameSessions" ], "Resource": "*" }}

Stratégie de placement de sessions de jeu manuel

Cet exemple de stratégie présente un client de jeu ou un service client qui crée de nouvelles sessionsde jeu sur des parcs spécifiques et peut créer de nouvelles sessions de joueur dans des sessions de jeu

Version25

Amazon GameLift Manuel du développeurConfiguration d'un rôle pour lGameLift'accès

spécifiques. Ce scénario prend en charge un jeu qui utilise une méthode de type « list-and-pick » pourpermettre aux joueurs de choisir parmi la liste des sessions de jeu disponibles.

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

Configuration d'un rôle pour lGameLift'accèsCette rubrique fait référence aux solutions GameLift hébergées. Si vous utilisez GameLift FleetIQ pouroptimiser l'hébergement des jeux sur vos instances EC2, consultez Configurez votre compte AWS pourGameLift FleetIQ (p. 229) .

Certaines fonctions d'GameLift exigent que vous étendiez l'accès limité à vos ressources AWS. Pour cela,vous devez créer un rôle AWS Identity and Access Management (IAM). Un rôle spécifie deux choses : (1)qui peut assumer le rôle et (2) quelles ressources peuvent être contrôlées lors de l'utilisation du rôle. Cetterubrique fournit des conseils sur la manière de configurer un rôle pour étendre l'accès au service GameLift.

Les utilisateurs qui effectuent des appels d'API qui étendent ce rôle à GameLift doivent disposerPassRole d'autorisations IAM, comme illustré dans Exemples de stratégies simples pour lesadministrateurs (p. 24) .

Pour configurer un rôle IAM pour le service GameLift

En créant un rôle spécifiquement pour GameLift, vous définissez les ressources AWS auxquelles le serviceGameLift ou vos applications (telles que les serveurs de jeu) qui s'exécutent sur GameLift ont accès.

Actuellement, un rôle spécifique au service pour Amazon GameLift doit être créé manuellement avec desautorisations et des stratégies d'approbation en ligne. Vous pouvez mettre à jour le rôle à tout moment àl'aide du service IAM via la console ou l'interface de ligne de commande AWS.

1. Création d'un rôle IAM à l'aide de l'interface de ligne de commande AWS (La console IAM ne vouspermet pas actuellement de créer un rôle de service générique et d'ajouter ou de modifier desstratégies.) Pour obtenir des instructions spécifiques, consultez la rubrique IAM Création d'un rôle pourun service (interface de ligne de commande AWS). Le rôle doit être créé sous le compte AWS quevous utilisez pour gérer GameLift. Par conséquent, assurez-vous que vous utilisez les informationsd'identification du compte AWS approprié.

2. Créez une stratégie d'autorisations en ligne et attachez-la au rôle. C'est dans la stratégied'autorisations que vous spécifiez le niveau d'accès couvert par le rôle. Vous pouvez spécifier l'accès àun service ou à une ressource, telle qu'un compartiment Amazon S3, et limiter les autorisations à desactions spécifiques. Vous pouvez choisir de créer des rôles IAM distincts pour différents ensemblesd'autorisations afin de limiter la vulnérabilité. Consultez ces Exemples de stratégies pour la délégationd'accès. Une fois que vous avez défini la syntaxe de votre stratégie, attachez celle-ci au servicecomme décrit dans les instructions liées à l'étape 1.

Version26

Amazon GameLift Manuel du développeurGameLift SDKs

3. Créez une stratégie d'approbation et attachez-la au rôle. Une stratégie d'approbation spécifies le ou lesservices AWS qui peuvent assumer le rôle. Utilisez la syntaxe suivante :

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

4. Après avoir créé le rôle, vous pouvez le voir dans la console IAM. Notez l'ARN du nouveau rôle, carvous pouvez en avoir besoin lors de la configuration d'une fonction GameLift.

GameLift SDKsCette rubrique décrit le SDKs à utiliser avec les GameLift pour les builds de serveur de jeux personnaliséeset Serveurs en temps réel. Pour en savoir plus sur les autres solutions GameLift, veuillez consulterPrésentation d'Amazon GameLift? (p. 1).

Utilisez des kits SDK GameLift pour développer des serveurs de jeux multijoueur compatibles avecGameLift, des clients de jeu et des services de jeux qui doivent communiquer avec le service GameLift.

Pour plus d’informations sur l’utilisation de l’ GameLift SDKs avec votre moteur de jeu, voir Moteurs de jeuxet Amazon GameLift (p. 37). Pour obtenir les dernières informations sur GameLift SDKs et compatibilitéSDK, voir Notes de mise à jour pour GameLift (p. 346).

Pour les serveurs de jeux personnalisésCréez et déployez des serveurs de jeux 64 bits personnalisés avec le kit SDK GameLift Server. Ce kit SDKpermet au service GameLift de déployer et de gérer des processus de serveur de jeux sur vos ressourcesd'hébergement GameLift. Téléchargez le kit SDK Server et découvrez comment Ajouter GameLift versvotre serveur de jeux (p. 46) projets. Voir Notes de mise à jour pour GameLift (p. 346) pour desinformations spécifiques à la version.

Prise en charge de SDK

Le kit SDK GameLift Server contient la source des versions suivantes. Générez la version dont vous avezbesoin pour votre jeu. Pour en savoir plus sur les instructions de génération et les exigences minimales,consultez les fichiers README de chaque version.

• C++• C++ pour Unreal Engine (plug-in)• C# (.NET)

Environnements de développement

Développez le kit de développement logiciel (SDK) de la source si nécessaire pour les systèmesd'exploitation de développement et les moteurs de jeu pris en charge.

• Systèmes d'exploitation – Windows, Linux

Version27

Amazon GameLift Manuel du développeurPour Serveurs en temps réel

• Moteurs de jeu – Amazon Lumberyard, Unreal Engine, Unity, moteurs qui prennent en charge lesbibliothèques C++ ou C#

Systèmes d'exploitation de serveur de jeux

Utilisez le kit SDK GameLift Server pour créer des serveurs de jeux qui s'exécutent sur les plateformessuivantes :

• Windows Server 2012 R2• Amazon Linux• Amazon Linux 2

Pour Serveurs en temps réelConfigurez et déployez des serveurs RealTime pour héberger vos jeux multijoueur et permettre à vosclients de jeu de s'y connecter avec le kit SDK de client GameLift Realtime. Les clients de jeu utilisent ce kitSDK pour échanger des messages avec un serveur RealTime et d'autres clients de jeu qui sont connectésà ce dernier. Téléchargez le client SDK RealTime et découvrez comment l'utiliser avec vos clients dejeu (p. 67).

Prise en charge de SDK

Le client SDK RealTimecontient la source pour les langages suivants :

• C# (.NET)

Environnements de développement

Développez le kit de développement logiciel (SDK) de la source si nécessaire pour les systèmesd'exploitation de développement et les moteurs de jeu pris en charge.

• Systèmes d'exploitation – Windows, Linux, Android, iOS.• Moteurs de jeu – Unity, moteurs qui prennent en charge les bibliothèques C#

Systèmes d'exploitation de serveur de jeux

Les serveurs RealTime sont déployés sur des ressources d'hébergement qui exécutent les plate-formessuivantes :

• Amazon Linux• Amazon Linux 2

Pour les services à la clientèleCréez des services client 64 bits en utilisant le kit AWS SDK avec l'API GameLift. Ce kit SDK permet auxservices client de trouver ou de créer des sessions de jeu, et d'associer les joueurs avec des jeux hébergéssur GameLift. Téléchargez le kit AWS SDK ou consultez la documentation de référence des API GameLift.

Prise en charge de SDK

Le kit AWS SDK avec Amazon GameLift est disponible dans les langages suivants. Consultez ladocumentation pour chaque langage et en savoir plus sur la prise en charge des environnements dedéveloppement.

Version28

Amazon GameLift Manuel du développeurOutils et ressources

• C++ (Docs SDK) (Amazon GameLift)• Java (Docs SDK) (Amazon GameLift)• .NET (Docs SDK) (Amazon GameLift)• Go (Docs SDK) (Amazon GameLift)• Python (Docs SDK) (Amazon GameLift)• Ruby (Docs SDK) (Amazon GameLift)• PHP (Docs SDK) (Amazon GameLift)• JavaScript/Node.js ((Docs SDK) (Amazon GameLift)

Outils et ressourcesAmazon GameLift fournit un ensemble d'outils et de ressources que vous pouvez utiliser.

Outils principauxUtilisez ces outils pour gérer Amazon GameLift.

Kits SDK Amazon GameLift

Les kits SDK Amazon GameLift contiennent les bibliothèques nécessaires à la communication avec leservice Amazon GameLift depuis vos clients de jeu, serveurs de jeux et services de jeux. Les versionsde ces kits SDK sont disponibles auprès d'Lumberyard, ou vous pouvez télécharger les dernièresversions séparément. Voir les informations dans GameLift SDKs (p. 27).

Kit SDK de client en temps réel Amazon GameLift

Pour des jeux qui utilisent Serveurs en temps réel, le kit SDK de client en temps réel permet à unclient de jeu de se connecter à un serveur RealTime déployé, de rejoindre une session de jeu etconserver son état de jeu synchronisée avec d'autres joueurs dans le jeu. Téléchargez le kit SDK etdécouvrez comment réaliser des appels d'API avec le Référence d'API de client Serveurs en tempsréel (C#) (p. 270).

Console AWS pour Amazon GameLift

Utilisez la AWS Management Console pour Amazon GameLift pour gérer vos déploiements dejeu, configurer des ressources, suivre l'utilisation des joueurs et les métriques de performance. Laconsole Amazon GameLift offre également une interface graphique pour gérer les ressources parprogrammation à l'aide du kit AWS SDK.

Interface de ligne de commande AWS pour Amazon GameLift

Utilisez cet outil de ligne de commande pour effectuer des appels au kit AWS SDK, y compris à l'APIAmazon GameLift. Obtenez le AWS Command Line Interface téléchargez-le et installez-le à l'aidede ces instructions. Vous pouvez également afficher l'intégralité de la Référence des commandesd'interface de ligne de commande AWS pour tous les services AWS, y compris Amazon GameLift.

Amazon GameLift Local

Cet outil de débogage côté client émule un sous-ensemble des API Amazon GameLift sur votremachine de développement local. Vous pouvez tester les modifications de code itératives sans avoirbesoin de charger et d'exécuter votre serveur de jeux sur des instances Amazon GameLift. AmazonGameLift Local peut être utilisé sous Windows et Linux pour tester les clients de jeux et les serveursde jeux qui utilisent les kits SDK Amazon GameLift. Amazon GameLift Local est disponible dans letéléchargement du kit SDK Server. Voir les informations dans Test de l'intégration (p. 61).

Version29

Amazon GameLift Manuel du développeurRessources supplémentaires

Ressources supplémentairesUtilisez ces ressources pour découvrir et tester Amazon GameLift pour vos jeux multijoueur.

Exemple en cinq clics

Obtenez un exemple de jeu multijoueur (serveur de jeux client et personnalisé) opérationnel surAmazon GameLift en moins d'une heure. Cet exemple vous permet de démarrer rapidement desexpériences avec des outils Amazon GameLift, configurer des flottes et déployer le serveur de jeuxpour l'hébergement, régler le dimensionnement et suivre l'activité et les performances du jeu. Voustrouverez l'exemple dans la console Amazon GameLift ; cliquez sur « Tester Amazon GameLift »à partir de la page d'introduction GameLift, ou sélectionnez « Exemple de jeu » dans le menu denavigation Amazon GameLift à partir de n'importe quelle autre page de console.

Forum Amazon GameLift

Utilisez le forum Amazon GameLift pour échanger des idées et des connaissances, récupérer desconseils et obtenir de l'aide sur les problèmes rencontrés.

Blog GameTech

Regardez le blog de développement de jeu pour vous tenir informé des nouvelles fonctions AmazonGameLift, Amazon Lumberyard, en savoir plus sur le développement de jeux avec AWS, et obtenir desconseils d'expert de la part des équipes.

Exemples AWS sur GitHub

Vous trouverez un vaste ensemble d'exemples de code pour tous les services AWS dans ExemplesAWS.

Tutoriels de mise en route

Utilisez les didacticiels pour explorer le processus de mise en place d'un jeu multijoueur dans AmazonGameLift. Une fois que vous avez terminé la série, vous pouvez utiliser le jeu pour explorer lesautres fonctions et outils d'Amazon GameLift, tels que la scalabilité automatique et les métriques deperformances .

Informations sur le produit Amazon GameLift

Consultez ces pages pour accéder à des descriptions détaillées sur Amazon GameLift, y compris uneprésentation du service, une foire aux questions (FAQ) et des informations de tarification.

Moteur de jeu Amazon Lumberyard

Amazon Lumberyard est fourni avec les kits SDK Amazon GameLift intégrés, et cette intégrationest gérée automatiquement. Il contient un exemple de jeu multijoueur qui illustre comment utiliserLumberyard pour intégrer un jeu avec Amazon GameLift. Pour plus d'informations sur cet exemple deprojet, consultez le Guide de l'utilisateur Lumberyard.

Configuration des alertes de facturation AWSVous souhaiterez peut-être configurer une alerte de facturation pour vous prévenir en cas d'événement defacturation. Pour plus d'informations, consultez Création d'une alarme de facturation.

En plus de recevoir des alertes de facturation, vous pouvez consulter l'estimation de votre facture en courspour GameLift sur la console Billing and Cost Management, à l'adresse https://console.aws.amazon.com/billing/. Vous pourrez ainsi vérifier votre consommation de ressources, prendre des décisions surl'utilisation future et déterminer vos besoins de mise à l'échelle.

Pour éviter les frais inutiles, vous pouvez envisager de réduire votre flotte (p. 135) lorsqu'elle n'est pasutilisée.

Version30

Amazon GameLift Manuel du développeurUtilisation d'GameLift dans les régions AWS

Utilisation d'Amazon GameLift dans les régionsAWS

Amazon GameLift est disponible dans plusieurs régions AWS. Pour obtenir la liste complète des régionset points de terminaison AWS, consultez Régions et points de terminaison AWS. Un compte AWS mondialvous permet d'utiliser les ressources dans la plupart des régions.

Lorsque vous utilisez Amazon GameLift pour les ressources de la région Région Chine (Pékin), qui estgérée par Sinnet, n'oubliez pas que vous devez disposer d'un compte AWS (Chine) distinct. En outre, ilexiste quelques différences dans la façon dont Amazon GameLift est mis en œuvre, y compris la façondont il gère les interactions entre régions. Pour plus d'informations sur l'utilisation d'Amazon GameLift dansla région Région Chine (Pékin), consultez les ressources suivantes :

• AWS en Chine• Amazon GameLift en Chine

Version31

Amazon GameLift Manuel du développeurExploration d'GameLift

Démarrez avec Amazon GameLiftLes ressources de cette section vous aident à démarrer avec les solutions GameLift gérées pour lesserveurs de jeux personnalisés et les Serveurs en temps réel.

Rubriques• Exploration d'Amazon GameLift (p. 32)• Premiers pas avec les serveurs personnalisés (p. 33)• Premiers pas avec Serveurs en temps réel (p. 35)

Exploration d'Amazon GameLiftVous souhaitez tester les fonctionnalités Amazon GameLift avant de vous lancer avec votre proprejeu ? Testez ces exemples d'expériences. Les exemples de la console vous permettent d'acquérir uneexpérience pratique de l'hébergement de jeux dans la console GameLift. L'exemple de code source et laprocédure vous montrent comment préparer un jeu pour l'hébergement à l'aide de Serveurs en temps réel.

Exemple de jeu Serveurs en temps réel (sourcecomplète)Mega Frog Race est un exemple de jeu multijoueur complet avec code source. Suivez un didacticielpratique qui vous explique comment préparer l'exécution en ligne de l'exemple à l'aide de GameLiftServeurs en temps réel. Cet exemple vous aide à mieux comprendre comment préparer votre client de jeuafin de l'utiliser avec GameLift Serveurs en temps réel. Vous pouvez également l'utiliser comme point dedépart pour tester d'autres fonctionnalités GameLift telles que FlexMatch.

Pour lire le didacticiel pratique, veuillez consulter le billet de blog GameTech Creating Servers forMultiplayer Mobile Games with Just a Few Lines of JavaScript.

Pour obtenir le code source, veuillez consulter le référentiel GitHub.

Les éléments source pour l'exemple MegaFrogRace incluent tous les éléments nécessaires audéploiement du jeu multijoueur hébergé avec Serveurs en temps réel.

• Client de jeu – Code source pour le client de jeu C++ créé par Unity. Il illustre la procédure qui permetd'obtenir les informations de connexion de session de jeu auprès de GameLift, de se connecter à unserveur RealTime et d'échanger des mises à jour de jeu avec d'autres joueurs via le serveur RealTime.

• Service client – Source (en JavaScript basé sur le nœud) pour une fonction AWS Lambda qui gère desappels directs d'API pour le service GameLift. Lorsqu'il est appelé par le client de jeu, le service effectuedes demandes pour trouver ou démarrer de nouvelles sessions de jeu et affecter des joueurs, puisrenvoie les détails de connexion au client de jeu.

• Script RealTime – Fichier de script source (en JavaScript basé sur le nœud) qui configure un groupe deserveurs RealTime pour le jeu. Ce script inclut la configuration minimale pour permettre aux serveursRealTime de communiquer avec le service GameLift et pour démarrer et arrêter les sessions de jeu. Ilinclut également une logique personnalisée pour l'exemple de jeu.

Version32

Amazon GameLift Manuel du développeurExemple de serveur de jeu

personnalisé (Experience de console)

Exemple de serveur de jeu personnalisé (Experiencede console)Cet exemple d'expérience vous permet d'obtenir rapidement un jeu en direct sur GameLift. Chargez unexemple de build de jeu, créez une flotte pour exécuter le serveur de jeu et connectez-vous à ce serveurà partir d'un exemple de client de jeu. Vous pouvez démarrer plusieurs clients de jeu et jouer pour générerdes données d'hébergement. Une fois que vous disposez de données, explorez la console GameLiftpour afficher vos ressources d'hébergement, suivre les métriques et tester différentes méthodes pourdimensionner la capacité d'hébergement.

Pour accéder à l'exemple d'assistant, connectez-vous à la console GameLift, ouvrez le menu AmazonGameLift et sélectionnez Custom game server sample (Exemple de serveur de jeu personnalisé).

À propos de l'exemple de jeu

L'exemple de jeu est développé à l'aide du moteur de jeu Amazon Lumberyard. Pour exécuter le clientde jeu, vous devez disposer d'un système Windows 7 de 64 bits et d'un espace de 300 Mo. Consultez lesexigences supplémentaires.

Premiers pas avec les serveurs personnalisésCette feuille de route décrit les étapes clés pour rendre opérationnels vos jeux multijoueurs avec desserveurs de jeux personnalisés avec la solution GameLift gérée pour les serveurs de jeux personnalisés.Si vous souhaitez utiliser les Serveurs en temps réel GameLift, ce qui vous permet de déployer votreclient de jeu avec nos serveurs de jeu prêts à déployer, veuillez consulter Premiers pas avec Serveurs entemps réel (p. 35). Pour en savoir plus sur les autres solutions GameLift, veuillez consulter Présentationd'Amazon GameLift? (p. 1).

Conseil

Informez-vous sur les façons d'explorer les fonctions Amazon GameLift, en particulier Serveurs entemps réel, à l'aide des exemples de jeux. (p. 32).

Vous ne connaissez pas encore GameLift ? Nous vous conseillons de lire Présentation d'AmazonGameLift? (p. 1). Si vous n'êtes pas certain que GameLift prend en charge vos systèmes d'exploitation etenvironnements de développement, veuillez consulter les rubriques GameLift SDKs (p. 27) et Moteurs dejeux et Amazon GameLift (p. 37).

Avant de commencer, vous devez posséder un compte AWS configuré pour Amazon GameLift. Découvrez-en plus sur Configuration d'un compte AWS (p. 23). Toutes les tâches clés liées à la création et la gestionde vos serveurs de jeux peuvent être effectuées à l'aide de la console Amazon GameLift, mais vouspouvez également Obtenez et installez l'outil AWS Command Line Interface.

1. Préparez votre serveur de jeux personnalisé pour l'hébergement sur Amazon GameLift.

• Obtenez le kit SDK Server Amazon GameLift et préparez-le pour le langage de programmationet le moteur de jeu de votre choix. Si vous utilisez le moteur de jeu Amazon Lumberyard, uneversion du kit SDK est intégrée. Consultez les kits SDK Amazon GameLift Pour les serveurs de jeuxpersonnalisés (p. 27) et Moteurs de jeux et Amazon GameLift (p. 37).

• Ajoutez du code à votre projet de serveur de jeux pour activer la communication avec le serviceAmazon GameLift. Un serveur de jeux doit être en mesure d'informer Amazon GameLift sur sonstatut, d'arrêter/de démarrer des sessions de jeu lorsqu'il y est invité, et d'autres tâches. Voir AjouterGameLift vers votre serveur de jeux (p. 46).

2. Préparer votre client de jeu à se connecter aux sessions de jeu hébergées par Amazon GameLift.

Version33

Amazon GameLift Manuel du développeurPremiers pas avec les serveurs personnalisés

• Configurez un service client pour communiquer avec le service Amazon GameLift afin de démarrerdes sessions de jeu et de placer des joueurs dans des parties sur l'invite d'un client de jeu.• Ajoutez le kit SDK AWS à votre projet de service client. Consultez les kits SDK Amazon GameLift

Pour les services à la clientèle (p. 28).• Ajoutez une fonctionnalité pour récupérer des informations sur les sessions de jeu, placez de

nouvelles sessions de jeu et (facultatif) réserver de l'espace pour les joueurs dans une sessionde jeu. Voir Ajout d'Amazon GameLift à votre client de jeu (p. 53). Recommandé : utilisez desplacements de sessions de jeux afin d'exploiter FleetIQ et d'optimiser l'utilisation des ressourceset l'expérience des joueurs. Cette option est obligatoire si vous utilisez FlexMatch.

• (facultatif) Activez le service client pour demander une mise en relation des joueurs en utilisantFlexMatch. En savoir plus dans feuille FlexMatch de route de l'intégration d' (p. 78).

• Permettez à votre client de jeu de se connecter directement à une session de jeu hébergée.Ajoutez du code afin d'obtenir les informations de connexion d'une session de jeu et (facultatif) unesession de joueur réservée. Utilisez ces informations de connexion et un ID de joueur unique pourcommuniquer avec le serveur de jeux et rejoindre le jeu. Voir Ajout d'un joueur à une session dejeu (p. 56).

3. Tester votre intégration Amazon GameLift.

• Utilisez Amazon GameLift Local pour tester l'intégration de votre client de jeu et de votre serveur dejeux à l'aide d'une version du service Amazon GameLift s'exécutant localement. Vous pouvez utilisercet outil pour tester votre intégration sans avoir à charger de build de jeu ni configurer de flotte. Vouspouvez vérifier que les composants de votre jeu communiquent avec le service Amazon GameLift ettester les fonctionnalités de base. Voir Test de l'intégration (p. 61).

4. Créer une flotte de ressources informatiques virtuelles pour héberger votre jeu.

• Assemblez et chargez la version de génération de votre serveur de jeux et téléchargez-la dans leservice Amazon GameLift. Veillez à charger votre build dans toutes les régions dans lesquellesvous prévoyez de déployer votre jeu. Voir Charger une build de serveur personnalisée surGameLift (p. 101).

• Concevez une configuration de flotte pour votre jeu. Décidez, par exemple, le type de ressourcesinformatiques à utiliser, les régions dans lesquelles déployer, l'utilisation de files d'attente ou d'autresoptions. Voir Guide de conception de flotte GameLift (p. 110).

• Créez des flottes et déployez-les avec votre serveur de jeu personnalisé. Dès qu'une flotte estactive, elle peut être utilisée pour héberger des sessions de jeu et accepter des joueurs. VoirConfiguration de flottes GameLift (p. 110).

• Essayez des paramètres de configuration de flotte Amazon GameLift et affinez-les selon vosbesoins pour optimiser l'utilisation des ressources de votre flotte. Ajustez le nombre de sessions dejeu à exécuter simultanément sur chaque instance ou définissez des limites d'activation de sessionsde jeu. Voir Guide de conception de flotte GameLift (p. 110). Consultez également comment Accèsà distance aux instances de flotte GameLift (p. 130).

• Créez une file d'attente pour gérer la façon dont les nouvelles sessions de jeu sont placées avecles ressources d'hébergement disponibles. Voir Conception d'une file d'attente de session dejeu (p. 143).

• Activez la scalabilité automatique pour gérer la capacité d'hébergement de votre flotte pour lademande prévue des joueurs. Voir Dimensionnement de la capacité d'une flotte GameLift (p. 133).

• (facultatif) Configurez une mise en relation FlexMatch avec un ensemble personnalisé de règlesde mise en relation pour votre jeu. En savoir plus dans feuille FlexMatch de route de l'intégrationd' (p. 78).

Version34

Amazon GameLift Manuel du développeurPremiers pas avec Serveurs en temps réel

Note

Une fois que vous avez créé vos files d'attente, il faut mettre à jour votre service client pourutiliser l'ID de la bonne file d'attente lors de la requête de placements de sessions de jeu et/oud'une mise en relation.

Une fois que vous avez entièrement intégré Amazon GameLift aux composants de votre jeu, il convientde gérer les flottes de vos serveurs de jeux afin qu'elles offrent une disponibilité et des performancesoptimales sur le long terme. Utilisez les outils Amazon GameLift pour effectuer le suivi de certainséléments, comme la rapidité et l'efficacité avec lesquelles les joueurs peuvent trouver et se connecter àune session de jeu, les performances globales de vos serveurs de jeux au fil du temps et les modèlesd'utilisation des joueurs. Voir Affichage de vos données de jeu sur la console (p. 193).

Premiers pas avec Serveurs en temps réelCette feuille de route décrit les principales étapes pour rendre vos clients de jeu multijoueur opérationnelssur la solution GameLift gérée avec Serveurs en temps réel. Si vous disposez d'un jeu avec un serveurde jeu personnalisé, veuillez consulter Premiers pas avec les serveurs personnalisés (p. 33). Pour ensavoir plus sur les autres solutions GameLift, veuillez consulter Présentation d'Amazon GameLift? (p. 1).

Vous ne connaissez pas encore Serveurs en temps réel ou vous ne savez pas si cette fonctionnalitéest appropriée pour votre jeu ? Nous vous conseillons de lire Fonctionnement des Serveurs en tempsréel (p. 9).

Note

Si vous n'êtes pas encore familiarisé avec la façon d'intégrer et de déployer vos jeux avecGameLift, voici un bref résumé de ce qui diffère avec les Serveurs en temps réel :

• Créez et chargez un script RealTime avec une logique de jeu en option pour exécuter dessessions de jeu sur les instances Serveurs en temps réel. Vous n'avez plus besoin dedévelopper un serveur de jeux personnalisé et de l'intégrer au kit SDK GameLift Server.

• Lorsque vous créez une flotte pour héberger vos sessions de jeu, déployez-la avec le scriptRealTime au lieu d'une build de serveur de jeu.

• Lorsque vous créez une flotte pour héberger vos sessions de jeu, déployez-la avec le scriptRealTime au lieu d'une build de serveur de jeu.

• Intégrez votre client de jeu avec le kit SDK client RealTime afin de gérer les connexions auxsessions de jeu.

Avant de commencer, vous devez posséder un compte AWS configuré pour GameLift. Découvrez-en plussur Configuration d'un compte AWS (p. 23). Toutes les tâches clés liées à la création et la gestion de vosserveurs de jeux peuvent être effectuées à l'aide de la console GameLift, mais vous pouvez égalementObtenez et installez l'outil AWS Command Line Interface.

1. Créez un script RealTime pour l'hébergement sur GameLift.

• Créez un script RealTime avec votre configuration de serveur et une logique de jeu personnaliséefacultative. Les Serveurs en temps réel sont prêts à démarrer et arrêter les sessions de jeu, àaccepter les connexions de joueurs et à gérer la communication avec le service GameLift et entreles joueurs dans un jeu. Il existe également des hooks qui vous permettent d'ajouter une logique deserveur personnalisée pour votre jeu. Les Serveurs en temps réel s'appuient sur Node.js et le scriptde serveur est écrit en JavaScript. Voir Création d'un script RealTime (p. 71).

2. Créer une flotte de ressources informatiques virtuelles pour héberger votre jeu.

Version35

Amazon GameLift Manuel du développeurPremiers pas avec Serveurs en temps réel

• Chargez le script RealTime dans le service GameLift. Veillez à charger votre script sur toutes lesrégions dans lesquelles vous prévoyez de déployer votre jeu. Voir Chargement d'un Serveurs entemps réel script dansGameLift (p. 107).

Concevez une configuration de flotte pour votre jeu. Décidez, par exemple, le type de ressourcesinformatiques à utiliser, les régions dans lesquelles déployer, l'utilisation de files d'attente ou d'autresoptions. Voir Guide de conception de flotte GameLift (p. 110).

• Créez des flottes Serveurs en temps réel et déployez-les avec le script RealTime. Dès qu'une flotteest active, elle peut être utilisée pour héberger des sessions de jeu et accepter des joueurs. VoirConfiguration de flottes GameLift (p. 110).

• Essayez des paramètres de configuration de flotte GameLift et affinez-les selon vos besoins pouroptimiser l'utilisation des ressources de votre flotte. Ajustez le nombre de sessions de jeu à exécutersimultanément sur chaque instance ou définissez des limites d'activation de sessions de jeu. VoirGuide de conception de flotte GameLift (p. 110). Consultez également comment Accès à distanceaux instances de flotte GameLift (p. 130).

• Créez une file d'attente pour gérer la façon dont les nouvelles sessions de jeu sont placées avecles ressources d'hébergement disponibles. Voir Conception d'une file d'attente de session dejeu (p. 143).

• Activez la scalabilité automatique pour gérer la capacité d'hébergement de votre flotte pour lademande prévue des joueurs. Voir Dimensionnement de la capacité d'une flotte GameLift (p. 133).

• (facultatif) Configurez une mise en relation FlexMatch avec un ensemble personnalisé de règlesde mise en relation pour votre jeu. En savoir plus dans feuille FlexMatch de route de l'intégrationd' (p. 78).

3. Préparez votre client de jeu à rejoindre des sessions de jeu hébergées par GameLift.

• Créez un mécanisme pour attribuer des ID de joueur uniques à utiliser avec GameLift.• Configurez un service client pour envoyer des demandes à GameLift pour de nouvelles sessions

de jeu et pour réserver de l'espace pour les joueurs des sessions de jeu existantes. Voir Ajoutd'Amazon GameLift à votre client de jeu (p. 53).

• (facultatif) Activez le service client pour demander une mise en relation des joueurs en utilisantFlexMatch. En savoir plus dans feuille FlexMatch de route de l'intégration d' (p. 78).

• Activez votre client de jeu afin qu'il puisse se connecter directement à une session de jeu hébergéeen cours d'exécution sur un serveur RealTime et échanger des informations via la messagerie. VoirIntégration d'un client de jeu pour Serveurs en temps réel (p. 67).

Une fois que vous avez entièrement intégré GameLift et Serveurs en temps réel aux composants de votrejeu, il convient de gérer les flottes de vos serveurs de jeux afin qu'elles offrent une disponibilité et desperformances optimales sur le long terme. Utilisez les outils GameLift pour effectuer le suivi de certainséléments, comme la rapidité et l'efficacité avec lesquelles les joueurs peuvent trouver une session dejeu et s'y connecter , les performances globales de vos serveurs de jeux au fil du temps et les modèlesd'utilisation des joueurs. Voir Affichage de vos données de jeu sur la console (p. 193).

Version36

Amazon GameLift Manuel du développeurIntégration de jeux avec des serveurs de jeu personnalisés

Préparation de jeux pour AmazonGameLift

Pour rendre opérationnel votre jeu multijoueur sur le service GameLift géré, vous devez effectuer certainestâches pour configurer la communication entre votre jeu et le service GameLift. Les guides de cette sectionfournissent une aide détaillée pour l'intégration de votre jeu dans GameLift, que vous planifiez de déployerun serveur de jeu personnalisé ou d'utiliser des Serveurs en temps réel prêts à l'emploi dans GameLift, etpour l'ajout d'un service de mise en relation à l'aide de FlexMatch.

Conseil

Informez-vous sur les façons d'explorer les fonctions Amazon GameLift, en particulier Serveurs entemps réel, à l'aide des exemples de jeux. (p. 32).

Rubriques• Intégration de jeux avec des serveurs de jeu personnalisés (p. 37)• Intégration de jeux avec Amazon GameLift Serveurs en temps réel (p. 66)• Ajout en cours de mise en relation FlexMatch (p. 77)

Intégration de jeux avec des serveurs de jeupersonnalisés

Amazon GameLift vous fournit un ensemble complet d'outils pour préparer vos jeux multijoueurs et vosserveurs de jeux personnalisés à exécuter sur le service GameLift géré. Les kits SDK GameLift contiennentles bibliothèques nécessaires pour permettre aux clients et serveurs de jeu de communiquer avec leservice GameLift. Les kits SDK peuvent être téléchargés directement ; ils sont également inclus dans lemoteur de jeu Amazon Lumberyard. Pour plus d'informations sur les kits SDK et la façon de les obtenir,consultez GameLift SDKs (p. 27).

Les rubriques de cette section contiennent des instructions détaillées sur la façon d'ajouter lesfonctionnalités GameLift requises à votre client de jeu et au serveur de jeu avant le déploiement surGameLift. Pour obtenir une feuille de route complète afin de rendre votre jeu opérationnel sur GameLift,veuillez consulter Premiers pas avec les serveurs personnalisés (p. 33).

Rubriques• Moteurs de jeux et Amazon GameLift (p. 37)• Intégration de votre serveur de jeux pour Amazon GameLift (p. 45)• Intégration de votre client de jeu pour Amazon GameLift (p. 52)• GameLift et interactions client/serveur de jeu (p. 58)• Test de l'intégration (p. 61)

Moteurs de jeux et Amazon GameLiftVous pouvez utiliser le service GameLift géré avec la plupart des principaux moteurs de jeux qui prennenten charge les bibliothèques C++ ou C#, comme Amazon Lumberyard, Unreal Engine et Unity. Générezla version dont vous avez besoin pour votre jeu. Pour en savoir plus sur les instructions de générationet les exigences minimales, consultez les fichiers README de chaque version. Pour de plus amples

Version37

Amazon GameLift Manuel du développeurMoteurs de jeux et GameLift

informations sur les kits SDK GameLift disponibles, ainsi que sur les plateformes de développement etsystèmes d'exploitation pris en charge, veuillez consulter GameLift SDKs (p. 27) pour les serveurs de jeux.

En plus des informations spécifiques au moteur fournies dans cette rubrique, consultez l'aide surl'intégration de GameLift à vos serveurs de jeux, clients et services dans les rubriques suivantes :

• Premiers pas avec les serveurs personnalisés (p. 33) – flux de travail en six étapes pour intégrer avecsuccès GameLift à votre jeu et configurer les ressources d'hébergement.

• Ajouter GameLift vers votre serveur de jeux (p. 46) – instructions détaillées sur l'intégration deGameLift à un serveur de jeux.

• Ajout d'Amazon GameLift à votre client de jeu (p. 53) – instructions détaillées sur l'intégration à unclient de jeu ou un service, y compris la création de sessions de jeu et la participation de joueurs auxjeux.

Amazon LumberyardLes fonctionnalités et les kits SDK GameLift sont entièrement intégrés au produit Lumberyard.

Serveurs de jeux

Préparez vos serveurs de jeux pour l'hébergement sur GameLift à l'aide du Kit SDK GameLift Server pourC++ (p. 286). Consultez Ajouter GameLift vers votre serveur de jeux (p. 46) pour obtenir de l'aide surl'intégration des fonctionnalités requises à votre serveur de jeux.

Clients et services de jeux

Activez vos clients de jeu et/ou services de jeu pour interagir avec le service GameLift, comme la recherchede sessions de jeu disponibles ou la création de nouvelles sessions, et l'ajout de joueurs aux jeux.Les principales fonctionnalités client sont fournies dans le kit Kit SDK AWS pour C++. Pour intégrerGameLift à votre projet de jeu Lumberyard, veuillez consulter Ajouter GameLift à un client de jeu AmazonLumberyard (p. 39) et Ajout d'Amazon GameLift à votre client de jeu (p. 53).

Unreal EngineServeurs de jeux

Préparez vos serveurs de jeux pour l'hébergement sur GameLift en ajoutant le Kit SDK GameLift Serverpour Unreal Engine (p. 316) à votre projet et en mettant en œuvre la fonctionnalité serveur requise. Pourobtenir de l'aide pour configurer le plug-in Unreal Engine et ajouter le code GameLift, veuillez consulterAjout d'Amazon GameLift à un projet de serveur de jeux Unreal Engine (p. 40).

Clients et services de jeux

Activez vos clients de jeu et/ou services de jeu pour interagir avec le service GameLift, comme la recherchede sessions de jeu disponibles ou la création de nouvelles sessions, et l'ajout de joueurs aux jeux.Les principales fonctionnalités client sont fournies dans le kit Kit SDK AWS pour C++. Pour intégrerGameLift à votre projet de jeu Unreal Engine, veuillez consulter Ajout d'Amazon GameLift à votre client dejeu (p. 53).

UnityServeurs de jeux

Préparez vos serveurs de jeux pour l'hébergement sur GameLift en ajoutant le Kit SDK GameLift Serverpour C# (p. 301) à votre projet et en mettant en œuvre la fonctionnalité serveur requise. Pour obtenir del'aide pour effectuer la configuration à l'aide du plug-in Unity et ajouter le code GameLift, veuillez consulterAjout d'Amazon GameLift à un projet de serveur de jeux Unity (p. 43).

Version38

Amazon GameLift Manuel du développeurMoteurs de jeux et GameLift

Clients et services de jeux

Activez vos clients de jeu et/ou services de jeu pour interagir avec le service GameLift, comme la recherchede sessions de jeu disponibles ou la création de nouvelles sessions, et l'ajout de joueurs aux jeux. Lesprincipales fonctionnalités client sont fournies dans le kit Kit AWS SDK pour .NET. Pour intégrer GameLift àvotre projet de jeu Unity, veuillez consulter Ajout d'Amazon GameLift à votre client de jeu (p. 53).

Autres moteursPour obtenir la liste complète des kits SDK GameLift disponibles pour les serveurs de jeux et les clients dejeu, veuillez consulter the section called “GameLift SDKs” (p. 27).

Ajouter GameLift à un client de jeu Amazon LumberyardTous les clients de jeu doivent être configurés pour permettre la communication avec le service GameLiftgéré, notamment en ce qui concerne la flotte à utiliser, les informations d'identification d'accès, le modede connexion, etc. La méthode la plus simple consiste à créer un fichier de commandes qui définit lesvariables de console répertoriées de la manière suivante.

Conseil

Informez-vous sur les façons d'explorer les fonctions Amazon GameLift, en particulier Serveurs entemps réel, à l'aide des exemples de jeux. (p. 32).

Pour préparer le client de jeu

1. Dans votre fichier de commandes, définissez les variables de console suivantes pour lancer leclient de jeu. Ces variables ont été ajoutées à \dev\Code\CryEngine\CryNetwork\Lobby\LobbyCvars.

• gamelift_aws_access_key = partie des informations d'identification (p. 23) IAM pour unutilisateur disposant d'un accès « joueur » dans votre compte AWS

• gamelift_aws_secret_key = partie des informations d'identification (p. 23) IAM pour unutilisateur disposant d'un accès « joueur » dans votre compte AWS

• gamelift_fleet_id = ID unique d'une flotte active à laquelle se connecter• gamelift_alias_id = ID unique d'un alias pointant sur une flotte à laquelle se connecter• (Facultatif) gamelift_endpoint = Point de terminaison de serveur GameLift, la valeur par défaut

est gamelift.us-west-2.amazonaws.com• (Facultatif) gamelift_aws_region = Nom de la région AWS par défaut ; la valeur par défaut estus-west-2

• (Facultatif) gamelift_player_id = ID que vous générez pour identifier de manière unique unjoueur (p. 57)

2. Ajoutez la commande suivante pour lancer le navigateur de serveur :

Suivez ce modèle lorsque vous utilisez un GameLift ID de flotte (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]

Suivez ce modèle lorsque vous utilisez un GameLift ID d’alias (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]

Version39

Amazon GameLift Manuel du développeurMoteurs de jeux et GameLift

Ajout d'Amazon GameLift à un projet de serveur de jeux UnrealEngineCette rubrique vous aide à configurer et utiliser le plug-in du kit SDK GameLift Server pour UnrealEngine dans vos projets de serveur de jeux. Si vous n'êtes pas certain que le service GameLift prenden charge les systèmes d'exploitation que vous utilisez, veuillez consulter Pour les serveurs de jeuxpersonnalisés (p. 27).

Configuration du plug-in du kit SDK Unreal Engine Server

Suivez ces étapes pour préparer le plug-in du kit SDK GameLift Server pour Unreal Engine pour vos projetsde serveur de jeux.

Pour configurer le plug-in du kit SDK GameLift pour Unreal Engine

1. Téléchargez le Kit SDK GameLift Server. Pour vérifier que la configuration système requise de votrejeu est prise en charge, consultez GameLift SDKs (p. 27).

2. Créez les bibliothèques du kit SDK Server C++ pour Unreal. Le téléchargement SDK contientle code source pour C++ (consultez GameLift_<release date>\GameLift-SDK-Release-<version>\GameLift-cpp-ServerSDK-<version>). Consultez le fichier READMEdans ce répertoire pour connaître les exigences minimales et d'autres informations avant de créer le kitSDK.

Pour créer les bibliothèques SDK, accédez au répertoire GameLift-cpp-ServerSDK-<version>et compilez-le avec l'indicateur -DBUILD_FOR_UNREAL défini sur true. Les instructions ci-dessousmontrent comment procéder à la compilation à l'aide de cmake.

Pour les utilisateurs de Linux :

mkdir outcd outcmake -DBUILD_FOR_UNREAL=1 ..make

Les fichiers binaires suivants sont générés :

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

Pour les utilisateurs de Windows :

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

Les fichiers binaires suivants sont générés :

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

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

Pour plus d'informations sur la création du kit SDK C++, y compris les configurations minimalesrequises et les options de génération, consultez le fichier README.md inclus dans le téléchargement.

3. Ajoutez les fichiers binaires aux fichiers de plug-in GameLift. Ouvrez le répertoire de la version duplug-in de UE4 que vous utilisez (par exemple, GameLift-SDK-Release-3.3.0\GameLift-

Version40

Amazon GameLift Manuel du développeurMoteurs de jeux et GameLift

Unreal-plugin-3.3.0\UE4.21.1\GameLiftServerSDK). Copiez les fichiers binaires que vousavez créé à l'étape 2 dans le répertoire ThirdParty du plug-in Unreal :

Pour Linux, utilisez ces chemins :

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

pour Windows, utilisez ces chemins :

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

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

4. Importez le plug-in GameLift dans un projet. Il existe plusieurs façons d'importer un plug-in dansUnreal Engine. La méthode suivante ne nécessite pas l'éditeur Unreal.

a. Ajoutez le plug-in à votre projet de jeu. Le plug-in doit contenir l'ensemble des éléments durépertoire GameLiftServerSDK du plug-in, y compris les fichiers binaires générés.

b. Ajoutez le plug-in au fichier .uproject de votre jeu :

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

c. Ajoutez le nom du plug-in en tant que dépendance à la liste de ModuleRules de votre jeu.L'exemple suivant illustre un exemple de liste de noms de module avec le plug-in GameLift ajouté.

using UnrealBuildTool;

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

Ajout de code GameLift

Pour de plus amples informations sur l'ajout de fonctionnalités GameLift, veuillez consulter les rubriquessuivantes :

• Ajouter GameLift vers votre serveur de jeux (p. 46)• GameLift Référence d’API de serveur pour Unreal Engine (p. 316)

Lorsque vous ajoutez du code spécifique à GameLift à votre projet de jeu Unreal Engine, entourez le codeà l'aide de l'indicateur de préprocesseur WITH_GAMELIFT=1. Cet indicateur garantit que seules les buildsde serveur appellent l'API de l'infrastructure GameLift et vous permet d'écrire du code qui est exécutécorrectement, quel que soit le type de cible de build que vous produisez avec ce code.

Le code entouré de l'indicateur WITH_GAMELIFT=1 est uniquement traité si les conditions suivantes sontremplies :

Version41

Amazon GameLift Manuel du développeurMoteurs de jeux et GameLift

• Le plug-in a trouvé les fichiers binaires du kit SDK GameLift Server.• La version de génération est un serveur de jeux : Target.Type ==TargetRules.TargetType.Server

L'extrait de code suivant montre comment initialiser un serveur de jeux Unreal Engine avec GameLift.

//This is an example of a simple integration with GameLift server SDK that makes game server //processes go active on Amazon GameLift

// Include game project files. "GameLiftFPS" is a sample game name, replace with file names from your own game project#include "GameLiftFPSGameMode.h"#include "GameLiftFPS.h"#include "Engine.h"#include "EngineGlobals.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

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

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

//Respond to new game session activation request. GameLift sends activation request //to the game server along with a game session object containing game properties //and other settings. Once the game server is ready to receive player connections, //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 before shutting down the instance //that is hosting this game server to give it time to gracefully shut down on its own. //In this example, we simply tell GameLift we are indeed going to shut down. params->OnTerminate.BindLambda([=](){gameLiftSdkModule->ProcessEnding();});

//HealthCheck callback. GameLift invokes this callback about every 60 seconds. By default, //GameLift API automatically responds 'true'. A game can optionally perform checks on //dependencies and such and report status based on this info. If no response is received //within 60 seconds, health status is recorded as 'false'. //In this example, we're always healthy! params->OnHealthCheck.BindLambda([](){return true; });

//Here, the game server tells GameLift what port it is listening on for incoming player

Version42

Amazon GameLift Manuel du développeurMoteurs de jeux et GameLift

//connections. In this example, the port is hardcoded for simplicity. Since active game //that are on the same instance must have unique ports, you may want to assign port values //from a range, such as: //const int32 port = FURL::UrlConfig.DefaultPort; //params->port; 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;

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

Ajout d'Amazon GameLift à un projet de serveur de jeux UnityCette rubrique vous aide à configurer le kit SDK Server C# GameLift dans vos projets de serveur de jeuxUnity. Si vous n'êtes pas certain que le service GameLift géré prend en charge les systèmes d'exploitationque vous utilisez, veuillez consulter Pour les serveurs de jeux personnalisés (p. 27).

Configuration du kit SDK Server C# pour Unity

Suivez ces étapes pour créer le kit SDK GameLift Server pour C# et l'ajouter à vos projets de serveur dejeux Unity.

Pour configurer le kit SDK GameLift Server pour Unity

1. Téléchargez le Kit SDK GameLift Server. Pour vérifier que la configuration système requise de votrejeu est prise en charge, consultez GameLift SDKs (p. 27).

2. Développez les bibliothèques SDK C#. Consultez le fichier README.md relatif au kit SDK C# Serverpour connaître la configuration minimale requise et les options de build supplémentaires. Dans unIDE, chargez le fichier de solution que vous souhaitez utiliser. Pour générer les bibliothèques SDK,restaurez les packages Nuget et développez la solution.

3. Vérifiez les paramètres de configuration. Dans l'éditeur Unity, accédez à File (Fichier), Build Settings(Paramètres de build), Player Settings (Paramètres joueur). Sous Other Settings (Autres paramètres),Configuration, vérifiez les paramètres suivants :

• Version d'exécution du script : définir à la solution .NET que vous utilisez.4. Ajoutez les bibliothèques GameLift à Unity. Dans l'éditeur Unity, importez les bibliothèques qui ont été

produites par la version de génération dans le répertoire Assets/Plugins de votre projet. Consultezle fichier README.md pour obtenir la liste complète des bibliothèques pour la version du SDK que vousutilisez.

Ajout de code GameLift Server

Pour de plus amples informations sur l'ajout de fonctionnalités GameLift, veuillez consulter les rubriquessuivantes :

• Ajouter GameLift vers votre serveur de jeux (p. 46)• Référence d'API GameLift Server pour C++ (p. 301)

Version43

Amazon GameLift Manuel du développeurMoteurs de jeux et GameLift

L'exemple de code suivant utilise un comportement MonoBehavior pour illustrer une initialisation simpled'un serveur de jeux avec 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 public void Start() { //Set the port that your game service is listening on for incoming player connections (hard-coded here for simplicity) 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) => { //Respond to new game session activation request. GameLift sends activation request //to the game server along with a game session object containing game properties //and other settings. Once the game server is ready to receive player connections, //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; }, //Here, the game server tells GameLift what port it is listening on for incoming player //connections. In this example, the port is hardcoded for simplicity. Active game //that are on the same instance must have unique ports. listeningPort, new LogParameters(new List<string>() {

Version44

Amazon GameLift Manuel du développeurIntégration d’un serveur de jeux

//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()); } }

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

Intégration de votre serveur de jeux pour AmazonGameLiftVotre serveur de jeux personnalisé doit interagir avec le GameLift service, et éventuellement d’autresressources, une fois qu’il est déployé et en cours d’exécution sur les instances GameLift. Cette sectionfournit des conseils sur l’intégration de votre logiciel de serveur de jeux à GameLift.

L’intégration de votre serveur de jeux est l’étape 2 sur le Premiers pas avec les serveurspersonnalisés (p. 33) de la feuille de route. Ces rubriques supposent que vous avez créé un AWS et ont unprojet de serveur de jeux existant.

Les rubriques de cette section décrivent comment gérer les tâches d’intégration suivantes :

• Établissez une communication entre les GameLift et vos serveurs de jeux déployés et en coursd’exécution.

• Obtenez un certificat TLS pour établir une connexion sécurisée entre le client de jeu et le serveur dejeux.

• Activez votre logiciel de serveur de jeux, lorsqu’il est déployé sur un GameLift pour interagir avecd’autres ressources AWS.

• Permet aux processus du serveur de jeux d’obtenir des informations sur la flotte qu’ils exécutent sur.

Rubriques :

• Ajouter GameLift vers votre serveur de jeux (p. 46)• Communiquez avec d’autres ressources AWS de vos flottes (p. 49)

Version45

Amazon GameLift Manuel du développeurIntégration d’un serveur de jeux

• Obtenir des données de flotte pour un GameLift instance (p. 51)• GameLift Références du kit SDK du serveur :

• Référence d'API GameLift Server pour C++ (p. 286)• Référence d'API GameLift Server pour C++ (p. 301)• GameLift Référence d’API de serveur pour Unreal Engine (p. 316)

Ajouter GameLift vers votre serveur de jeuxVotre serveur de jeux personnalisé doit communiquer avec le GameLift une fois déployé et exécuté surGameLift instances. Chaque processus de serveur de jeux doit pouvoir répondre aux événements lorsqu’ilssont déclenchés par le GameLift du service après-vente. Il doit également conserver GameLift informé del’état du processus serveur et (facultatif) des connexions de joueur. Pour plus de détails sur la façon dontvotre serveur de jeux, votre client de jeu et le GameLift fonctionne ensemble pour gérer l’hébergement dejeux, voir GameLift et interactions client/serveur de jeu (p. 58).

Pour préparer votre serveur de jeux à interagir avec GameLift, ajoutez le GameLift vers votre projet deserveur de jeux et utilisez les fonctionnalités de base décrites dans cette rubrique. Le kit SDK Server estdisponible en plusieurs langues. Voir GameLift SDKs (p. 27) pour en savoir plus sur le GameLift du kit SDKdu serveur. Télécharger la dernière version du kit SDK Server.

Références de l’API du kit SDK du serveur :

• Référence API serveur C# (p. 286)• Référence API serveur C# (p. 301)• Référence API plug-in Unreal Engine (p. 316)

Initialiser le processus serveur

Cette tâche est requise.

Ajoutez du code pour établir la communication avec le GameLift et signalez que le processus serveur estprêt à héberger une session de jeu. Ce code doit être exécuté avant toute GameLiftcode dépendant de , telque lors du lancement de.

Note

Les noms des opérations d’API de serveur sont les mêmes dans toutes les langues disponibles.

1. Initialiser GameLift Client d’API en appelant InitSdk().2. Notifier GameLift qu’un processus serveur est prêt à héberger une session de jeu. Appeler

ProcessReady() (N°C (p. 307)) (C++ (p. 291)) (Unreal (non réaliste) (p. 318)) avec lesinformations suivantes. ProcessReady() ne doit être appelé qu’une seule fois par processusserveur.

• Numéro de port utilisé par le processus serveur. Le numéro de port et une adresse IP sont fournisaux clients de jeu à qui ils peuvent se connecter au processus serveur pour rejoindre une session dejeu.

• Emplacement des fichiers, tels que les journaux de session de jeu, que vous souhaitez GameLiftpour conserver. Il s’agit des fichiers qui sont générés par le processus serveur pendant unesession de jeu. Elles sont stockées temporairement sur l’instance où le processus serveur est encours d’exécution et sont perdues lorsque l’instance arrête. Tous les fichiers répertoriés ici sonttéléchargés sur le GameLift du service après-vente. Vous pouvez y accéder via le GameLift consoleou en appelant le GameLift API de service ObtenirUrlLogSessionGame(). Conseil Si votre parc estconfiguré pour exécuter plusieurs processus serveur simultanés par instance, envisagez d’utiliser unschéma de dénomination de fichier qui identifie de manière unique les sessions de jeu.

Version46

Amazon GameLift Manuel du développeurIntégration d’un serveur de jeux

• Noms des fonctions de rappel pouvant être appelées par le GameLift sur le processus serveur.Votre serveur de jeux doit implémenter ces fonctions. Les instructions pour la mise en œuvre de cesfonctions sont abordées dans le reste de cette rubrique. (Voir aussi ProcessParameters (p. 299).)• onHealthCheck (facultatif) est appelé régulièrement pour demander un rapport d’état de santé

au processus serveur.• onStartGameSession (obligatoire) est appelé lorsque le GameLift le service reçoit une

demande de démarrage d’une nouvelle session de jeu (API de service Séance de création dejeu()).

• onProcessTerminate (obligatoire) est appelé lorsque le service GameLift doit forcer la misehors service du processus serveur, ce qui permet à ce processus de s'arrêter de façon appropriée.

• onUpdateGameSession (facultatif) est appelé lorsque le service GameLift fournit un objet desession de jeu mis à jour au serveur de jeux ou fournit une mise à jour d'état sur une demandede renvoi de correspondance. Ce rappel est requis si vous utilisez le FlexMatch remblai (p. 18)fonction ; en savoir plus sur le remblai de correspondance sur Mise à jour des données de mise enrelation sur le serveur de jeux (p. 91).

Vous pouvez configurer un serveur de jeux pour accéder en toute sécurité aux ressources AWS quevous possédez ou contrôlez. Découvrez comment Communiquez avec d’autres ressources AWS devos flottes (p. 49).

État du processus du serveur de rapports

Cette tâche est facultative.

Ajouter un code pour implémenter la fonction de rappel onHealthCheck(). Cette fonction est appelée parle GameLift pour collecter périodiquement des métriques d’état à partir du processus serveur. La réponsedu processus serveur à une vérification de l’état est binaire : saine ou non saine. Pour implémenter cettefonction de rappel, procédez comme suit :

• Evaluez l'état du processus serveur à l'aide de toutes les mesures qui sont logiques pour votre jeu.Par exemple, vous pouvez signaler le processus serveur comme étant Non sain si des dépendancesexternes ont échoué ou si des métriques, comme la capacité mémoire, dépassent une limite définie.

• Terminez l'évaluation du statut et répondez au rappel dans les 60 secondes. Si le service GameLift nereçoit pas de réponse dans ce délai, il considère automatiquement que le processus serveur n'est passain.

• Retournez une valeur booléenne : true pour sain, false pour non sain.

Si vous choisissez de ne pas implémenter un rappel de vérification de l’état, le GameLift considère que leprocessus serveur est sain, sauf si le processus ne répond pas, auquel cas il est considéré comme nonsain.

Le statut du processus serveur est utilisé par le service GameLift pour arrêter de manière efficace lesprocessus non sains et libérer des ressources. Si un processus serveur continue d'être signalé commeétant non sain ou ne répond pas pendant trois vérifications de l'état consécutives, le service GameLift peutarrêter le processus et en démarrer un nouveau. Les métriques concernant l'état du processus serveurd'une flotte sont collectées et peuvent être affichées sur la console GameLift.

Récupérer un certificat TLS

Cette tâche est facultative.

Si le processus serveur est en cours d’exécution sur une flotte pour laquelle la génération de certificatsTLS est activée, vous pouvez récupérer le certificat TLS et l’utiliser pour établir une connexion sécuriséeavec un client de jeu et chiffrer la communication client/serveur. Une copie du certificat est stockée sur

Version47

Amazon GameLift Manuel du développeurIntégration d’un serveur de jeux

l'instance. Pour obtenir l’emplacement du fichier, appelez GetInstanceCertificate() (N°C (p. 303))(C++ (p. 287)) (Unreal (non réaliste) (p. 317)).

Démarrer une session de jeu

Cette tâche est requise.

Ajouter un code pour implémenter la fonction de rappel onStartGameSession. Le GameLift Le serviceappelle cette méthode afin de déclencher une nouvelle session de jeu sur le processus serveur, dans lecadre du placement de session de jeu ou des activités de placement de mise en relation.

Le onStartGameSession la fonction prend un Session de jeu objet en tant que paramètre d’entrée.Cet objet inclut des informations de session de jeu clés, telles que le nombre maximal de joueurs, et peutinclure des données de jeu et des données de joueur. L’implémentation de la fonction doit accomplir lestâches suivantes :

• Initier des actions pour créer une nouvelle session de jeu en fonction de GameSession propriétés.Au minimum, le serveur de jeux doit associer l’ID de session de jeu, auquel les clients de jeu ferontréférence lors de la connexion au processus serveur.

• Traitez les données de jeu et les données de joueur selon vos besoins. Ces données se trouvent dans leGameSession objet,

• Notifier GameLift lorsque la nouvelle session de jeu est prête à accepter les joueurs. Appelerl’action d’API du serveur ActivateGameSession() (N°C (p. 303)) (C++ (p. 287)) (Unreal (nonréaliste) (p. 317)). En réponse à un appel réussi, le service GameLift passe la session de jeu à l'étatACTIVE.

Valider un nouveau joueur

Cette tâche est facultative.

Si vous suivez l’état des sessions de joueur, ajoutez du code pour vérifier une demande de connexionde joueur avec l’ GameLift du service après-vente. Ce code doit s’exécuter chaque fois qu’un nouveaujoueur tente de se connecter au processus serveur, avant d’accepter la connexion de joueur. Activation dela validation du joueur GameLift pour suivre les joueurs actuels et les emplacements disponibles dans lasession de jeu.

Les demandes de connexion d’un client de jeu incluent un ID de session de joueur. Cet ID est généré parle GameLift lorsque le client de jeu demande à de rejoindre une session de jeu (comme avec Emplacementde la session de jeu de début() ou CréerSessionJoueur()), utilisé pour réserver un emplacement de joueurdans la session de jeu et renvoyé au client de jeu. Lors de la réception d’une demande de connexion auclient de jeu, le processus serveur appelle AcceptPlayerSession() (N°C (p. 302)) (C++ (p. 286))(Unreal (non réaliste) (p. 316)) avec l’ID de session du joueur. GameLift vérifie que le client de jeudispose d’un emplacement de joueur réservé dans la session de jeu.

Une fois que l’ID de session du joueur est validé par GameLift, le processus serveur peut accepter laconnexion et autoriser le joueur à rejoindre la session de jeu. Si l'ID de session du joueur n'est pas validépar le service GameLift, le processus serveur doit refuser la connexion.

Signaler la fin d’une session de joueur

Cette tâche est facultative.

Si vous suivez l’état des sessions de joueur, ajoutez du code pour notifier le GameLift lorsqu’un joueurquitte la session de jeu. Ce code doit s'exécuter chaque fois que le processus serveur détecte uneconnexion abandonnée. Cette notification active le GameLift pour suivre avec précision les joueurs actuelset les emplacements disponibles dans la session de jeu.

Version48

Amazon GameLift Manuel du développeurIntégration d’un serveur de jeux

Dans votre code pour gérer les connexions abandonnées, ajoutez un appel à l’action d’API du serveurRemovePlayerSession() (N°C (p. 308)) (C++ (p. 294)) (Unreal (non réaliste) (p. 319)) avec l’ID desession de joueur correspondant.

Mettre fin à une session de jeuCette tâche est requise.

Ajoutez du code permettant d'indiquer au service GameLift qu'une session de jeu est en train de seterminer. Une bonne pratique consiste à arrêter les processus serveur une fois qu’une session de jeuest terminée afin de recycler et d’actualiser les ressources d’hébergement. Ce code doit être ajouté à laséquence d’arrêt du processus serveur.

Au début du code d’arrêt du serveur de processus, appelez l’action d’API du serveur ProcessEnding()(N°C (p. 306)) (C++ (p. 291)) (Unreal (non réaliste) (p. 318)). Cet appel informe le service GameLiftque le processus serveur est en cours d'arrêt. À la réception de cette notification, le GameLift change l’étatde la session de jeu et l’état du processus serveur en TERMINATED. Après l’appel ProcessEnding(), leprocessus peut être arrêté en toute sécurité.

Répondre à une notification d’arrêt du processus serveurCette tâche est requise.

Ajoutez le code pour arrêter le processus serveur en réponse à la notification du GameLift du serviceaprès-vente. GameLift envoie cette notification lorsque le processus serveur a été signalé comme étantconstamment défectueux, ou si l’instance sur laquelle le processus serveur est en cours d’exécution estarrêtée. Une instance peut être résiliée dans le cadre d’un événement de diminution de capacité ou enréponse à une interruption d’instance Spot.

Apportez les modifications suivantes au code de votre serveur de jeux pour gérer une notification d’arrêt :

• Implémenter la fonction de rappel onProcessTerminate(). Cette fonction doit appeler le code quiarrête le processus serveur. Quand GameLift appelle cette méthode, le processus serveur disposegénéralement de quelques minutes pour déconnecter correctement les joueurs, préserver les donnéesd’état du jeu et effectuer d’autres tâches de nettoyage. Les interruptions d’instance Spot fournissent unpréavis de deux minutes.

• Appeler l’action d’API du serveur GetTerminationTime() (N°C (p. 305)) (C++ (p. 290)) à partir ducode d’arrêt de votre serveur de jeux. Si GameLift a émis un appel pour mettre fin au processus serveur,GetTerminationTime() renvoie le temps de terminaison estimé.

• Au début du code d’arrêt de votre serveur de jeux, appelez l’action d’API du serveur ProcessEnding()(N°C (p. 306)) (C++ (p. 291)) (Unreal (non réaliste) (p. 318)). Cet appel informe le service GameLiftque le processus serveur est en cours d'arrêt. À la réception de cette notification, le GameLift changel’état du processus serveur en TERMINATED. Après l’appel ProcessEnding(), le processus peut êtrearrêté en toute sécurité.

Communiquez avec d’autres ressources AWS de vos flottesCette rubrique décrit comment configurer votre logiciel de serveur de jeux pour communiquer directementet en toute sécurité avec d’autres ressources AWS tout en exécutant sur GameLift instances. Par exemple,vous voulez peut-être :

• Envoyer les données des journaux d'instance aux journaux Amazon CloudWatch.• Capturer des métriques CloudWatch pour obtenir une meilleure visibilité sur les performances d'instance.• Obtenir des informations sensibles, telles que des mots de passe, qui sont stockées à distance dans un

compte Amazon S3.• Lire et écrire dynamiquement des données de jeu stockées dans Amazon DynamoDB ou d'autres

services de stockage de données, tels que des modes de jeu ou un inventaire.

Version49

Amazon GameLift Manuel du développeurIntégration d’un serveur de jeux

• Utiliser Amazon SQS pour envoyer des signaux directement à une instance.• Accéder à des ressources personnalisées qui sont déployées et exécutées sur Amazon EC2.

Lorsque vous déployez votre build de jeu avec GameLift, les parcs et les instances sont alloués à votrecompte, mais ils sont détenus par le GameLift du service après-vente. Pour que votre logiciel hébergéinteragisse avec les ressources AWS que vous possédez, vous devez accorder des autorisations d’accèslimitées à GameLift du service après-vente. Vous pouvez utiliser l’une des méthodes suivantes pour établircet accès :

• Créez un rôle AWS Identity and Access Management (IAM). Cette option est utile pour accéder à desressources associées directement à des services AWS, comme un compartiment Amazon S3, desmétriques Amazon CloudWatch ou des scripts AWS Lambda. Il s'agit de la méthode la plus simple etrecommandée.

• Paramétrer Amazon Virtual Private Cloud (VPC) connexions d’appairage. Il s'agit d'une fonctionnalitéavancée et non pas d'une solution couramment utilisée.

Accéder aux ressources AWS à l’aide d’un IAM rôleLes tâches suivantes doivent être effectuées pour permettre à votre serveur de jeu ou à d'autresapplications d'accéder à vos ressources AWS lors de leur exécution sur des instances GameLift.

1. Configuration d'un rôle IAM pour le service GameLift Suivez les instructions de Configuration d'un rôlepour lGameLift'accès (p. 26) pour créer un rôle IAM. Un rôle définit un ensemble d'autorisations pourun accès limité à vos ressources AWS et spécifie l'entité (dans ce cas, le service GameLift) qui peutassumer le rôle. Une fois que vous avez créé le rôle, notez le nom Amazon Resource Name (ARN) dunouveau rôle. Vous en aurez besoin lors de la création d'une flotte.

2. Associer le rôle de service à un GameLift flotte. Une fois que le rôle de service a été créé, vous devezpermettre à vos serveurs de jeu et autres applications d'assumer ce rôle lors de leur exécution surdes instances GameLift. Pour ce faire, vous devez fournir l'ARN du rôle de service à une flotte. Lesapplications qui s'exécutent sur une instance de la flotte peuvent alors assumer le rôle et acquérir lesinformations d'identification nécessaires pour l'accès.

Un rôle de service peut uniquement être spécifié lors de la création de la flotte. Une fois que la flotteest créée, vous ne pouvez pas ajouter l'ARN du rôle. Un seul ARN peut être fourni à une flotte.

Pour obtenir de l'aide afin de fournir un ARN de rôle de service à une flotte, consultez Déployer uneflotte GameLift pour une build de jeu personnalisée (p. 116).

3. Ajoutez du code à votre application pour que celle-ci assume le rôle de service. Toute applicationqui s'exécute sur une instance GameLift peut assumer un rôle IAM, s'il est associé à la flotte. Celainclut les serveurs de jeux et d'autres fichiers exécutables, comme des scripts et des démons. Uneapplication peut accéder à des ressources lors de la création d'une flotte et l'installation d'une build,lors du démarrage ou de l'arrêt de processus de service et de sessions de jeu, ou en réponse à desévénements de jeu.

Dans le code d'application, avant d'accéder à une ressource AWS, l'application doit d'abord assumerle rôle de service en appelant l'API AWS Security Token Service AssumeRole et en spécifiantl'ARN de rôle de service qui est associé à la flotte. Cette action renvoie un ensemble d'informationsd'identification temporaires qui permettent à l'application d'accéder à la ressource AWS. En savoir plussur l'Utilisation des informations d'identification de sécurité temporaires pour demander un accès auxressources AWS.

Accès aux ressources AWS avec l’appairage de VPCVous pouvez utiliser l'appairage de VPC (Amazon Virtual Private Cloud) pour établir une communicationrapide et sécurisée entre une application exécutée sur une instance GameLift et une autre ressource AWS.

Version50

Amazon GameLift Manuel du développeurIntégration d’un serveur de jeux

Un Amazon VPC est un réseau virtuel défini par vos soins, qui inclut un ensemble de ressources géréesvia votre compte AWS. Chaque flotte GameLift est dotée de son propre VPC. Avec l'appairage de VPC,vous pouvez établir une connexion réseau directe entre le VPC de votre flotte et le VPC de vos autresressources AWS.

Par exemple, vous pouvez disposer d'un ensemble de services web qui prennent en charge votre jeu,tels que l'authentification du joueur ou les réseaux sociaux. Vous pouvez configurer un VPC pour cesressources, puis utiliser l'appairage de VPC GameLift pour permettre à vos serveurs de jeu d'effectuer desappels réseau directs en direction des services web. Avec l'appairage VPC, les appels des processus devotre serveur de jeux encourent une latence minimale et, comme ils ne sont pas acheminés via l'Internetpublic, ils ne sont pas exposés en externe.

GameLift rationalise le processus de configuration des connexions d'appairage de VPC pour vos serveursde jeu. Il gère les demandes d'appairage, met à jour les tables de routage et configure les connexionsrequises. Pour plus d'informations sur la configuration de l'appairage de VPC pour vos serveurs de jeux,consultez Homologation VPC pour GameLift (p. 187).

Obtenez plus d'informations sur les Virtual Private Cloud (VPC) Amazon et l'appairage de VPC. Vouspouvez associer vos flottes GameLift aux VPC de n'importe quel compte AWS auquel vous avez accès.

Obtenir des données de flotte pour un GameLift instanceIl y a des situations où votre build de jeu personnalisée ou Serveurs en temps réel une fois déployé etexécuté sur un GameLift , peut avoir besoin d’accéder aux informations sur le parc auquel l’instanceappartient. Par exemple, votre build de jeu ou script peut inclure du code pour :

• Surveillez l’activité de l’instance filtrée en fonction des données de parc.• Cumulez les métriques d’instance pour suivre l’activité par données de parc. De nombreux jeux utilisent

ces données pour les activités en direct.• Fournissez des données pertinentes aux services de jeu personnalisés, comme pour la mise en relation,

la mise à l’échelle de capacité supplémentaire ou les tests A/B.

Les informations de flotte sont disponibles sous forme de fichier JSON sur chaque instance auxemplacements suivants :

• Windows: C:\GameMetadata\gamelift-metadata.json• Linux: /local/gamemetadata/gamelift-metadata.json

Le gamelift-metadata.json inclut les données de flotte suivantes, qui correspondent aux attributsd’un GameLift Ressource de parc.

• fleetArn – Nom de la ressource Amazon (ARN) qui identifie le parc de l’instance actuelle. Cetidentifiant est unique dans toutes les régions AWS.

• fleetId – Identificateur unique attribué au parc de l’instance actuelle. Cet identifiant est spécifique àune région AWS.

• fleetName – Étiquette descriptive attribuée au parc de l’instance actuelle.• fleetDescription – Description lisible par l’homme de la flotte. Une flotte ne nécessite pas d’attribut

de description.• fleetType – Indique si le parc utilise des instances Spot ou des instances à la demande. Le type de

parc détermine si toutes les instances d’un parc sont des instances Spot uniquement ou des instances àla demande uniquement.

• serverLaunchPath – L’emplacement d’un exécutable de build de jeu personnalisé ou d’un RealTimefichier de script sur l’instance. Chaque flotte dispose d’une configuration d’exécution avec une liste deprocessus serveur à lancer et à exécuter sur chaque instance de la flotte. La configuration du processus

Version51

Amazon GameLift Manuel du développeurIntégration d'un client de jeu

serveur inclut le chemin de lancement vers le fichier exécutable ou le fichier de script. En savoir plus surles Configuration de l’exécution et ProcessusServeur.

• instanceType – Type d’instance EC2 de l’instance actuelle. Toutes les instances du parc utilisentle même type d’instance. Pour obtenir des descriptions détaillées, reportez-vous à la section Typesd'instance Amazon EC2.

• instanceRoleArn – AWS Identity and Access Management rôle avec autorisations qui permet àl’instance actuelle d’interagir avec d’autres ressources AWS que vous possédez. Si une flotte estconfigurée avec un IAM , le rôle est disponible pour toutes les instances du parc. Avec un IAM rôle, touteapplication dans votre build de jeu ou script déployé, y compris les scripts d’installation, les processusserveur et les démons, peut accéder aux ressources AWS comme autorisé dans le rôle.

• buildArn – Nom de la ressource Amazon (ARN) pour la build de jeu personnalisée qui est déployée surl’instance actuelle. Cet identifiant est unique dans toutes les régions AWS. Une instance est déployéeavec une build de jeu personnalisée ou Serveurs en temps réel du script.

• buildId – Identificateur unique attribué à la build de jeu personnalisée qui est déployée sur l’instanceactuelle.

• scriptArn – Nom de la ressource Amazon (ARN) pour le Serveurs en temps réel qui est déployé surl’instance actuelle. Cet identifiant est unique dans toutes les régions AWS. Une instance est déployéeavec une build de jeu personnalisée ou Serveurs en temps réel du script.

• scriptId – Identificateur unique attribué au Serveurs en temps réel qui est déployé sur l’instanceactuelle.

Exemple de fichier JSON :

{ "buildArn":"arn:aws:gamelift:us-west-2:123456789012:build/build-1111aaaa-22bb-33cc-44dd-5555eeee66ff", "buildId":"build-1111aaaa-22bb-33cc-44dd-5555eeee66ff", "fleetArn":"arn:aws:gamelift:us-west-2:123456789012:fleet/fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa", "fleetDescription":"Test fleet for Really Fun Game v0.8", "fleetId":"fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa", "fleetName":"ReallyFunGameTestFleet08", "fleetType":"ON_DEMAND", "instanceRoleArn":"arn:aws:iam::123456789012:role/S3AccessForGameLift", "instanceType":"c5.large", "serverLaunchPath":"/local/game/reallyfungame.exe"}

Intégration de votre client de jeu pour AmazonGameLiftLes rubriques de cette section décrivent les fonctionnalités de la solution GameLift gérée que vous pouvezajouter à un client du jeu ou à un service de jeu. Un client ou un service de jeu peut avoir besoin de gérerles tâches suivantes :

• Demande d'informations sur les sessions de jeu actives à partir du service GameLift.• Ajout d'un joueur à une session de jeu existante.• Création d'une nouvelle session de jeu et ajout de joueurs.• Modification des métadonnées relatives à une session de jeu existante.

L'ajout de GameLift à votre client de jeux multijoueur est abordé à l'étape 5 de Premiers pas avec lesserveurs personnalisés (p. 33). Les instructions suivantes supposent que vous avez créé un compte AWS,

Version52

Amazon GameLift Manuel du développeurIntégration d'un client de jeu

généré un GameLiftsur le serveur de jeux activé et chargé sur GameLift, et utilisé GameLift outils (telsque le GameLift pour créer et configurer une flotte virtuelle pour héberger vos sessions de jeu. Lorsquevous ajoutez GameLift à votre client de jeu, vous devez être en mesure de fournir des informationsd'identification de compte AWS et de spécifier une flotte à utiliser avec le client.

Pour de plus amples informations sur la façon dont les clients de jeu interagissent avec le service GameLiftet les serveurs de jeux s'exécutant sur GameLift, veuillez consulter GameLift et interactions client/serveurde jeu (p. 58).

Rubriques• Ajout d'Amazon GameLift à votre client de jeu (p. 53)• Création de sessions de jeu avec les files d'attente (p. 57)• Génération d'ID de joueur (p. 57)

Ajout d'Amazon GameLift à votre client de jeuLorsque vous utilisez la solution GameLift gérée, vous pouvez intégrer GameLift aux composants de jeuqui ont besoin de récupérer des informations sur les sessions de jeu, créer de nouvelles sessions de jeu et/ou associer des joueurs à des jeux. En fonction de l'architecture de votre jeu, cette fonctionnalité peut êtreplacée dans le client de jeu ou dans les services de jeux qui gèrent des tâches telles que l'authentificationdes joueurs, la mise en relation ou le placement de jeu.

Pour cela, utilisez le kit AWS SDK avec l'API GameLift. Ce kit SDK est disponible en C++, C # et plusieursautres langages. Pour en savoir plus sur le kit AWS SDK, sur la version et sur la prise en charge deslangages, consultez Pour les services à la clientèle (p. 28). La plupart des liens de cette rubriquepermettent d'accéder au manuel Référence API de service GameLift, qui décrit l'API de service de basniveau des actions liées à GameLift et inclut les liens vers les guides de référence propres à chaquelangue.

Note

Vous êtes intéressé par l'utilisation de la mise en relation pour associer des joueurs à des jeux ?Une fois que vous avez configuré GameLift sur votre client de jeu ou sur un service, ajoutezFlexMatch pour mettre en relation les joueurs et créer des sessions de jeu personnalisées. Pourplus d'informations, consultez Ajout en cours de mise en relation FlexMatch (p. 77).

Configuration de GameLift sur un client ou un service

Vous ajoutez du code pour initialiser un GameLift et stocker certains paramètres clés à utiliser avecGameLift. Ce code doit se trouver à un emplacement qui permette son exécution avant le code dépendantd'GameLift, par exemple au lancement.

Note

Pour configurer votre client de jeu à des fins de test à l'aide de GameLift Local, veuillez consulterTest de l'intégration (p. 61).

1. Déterminez si vous devez utiliser la configuration client par défaut ou créer desparamètres personnalisés. Pour les paramètres personnalisés, vous devez créer un objetClientConfiguration personnalisé. Pour plus de détails sur la structure d'objet et les paramètrespar défaut, consultez AWS ClientConfiguration (C++).

Une configuration de client spécifie une région cible et un point de terminaison. La région détermineles ressources (flottes, files d'attente, matchmakers, etc.) avec lesquelles GameLift interagit lorsde la réponse aux demandes. La configuration client par défaut spécifie la région USA Est (Virginiedu Nord). Pour utiliser une autre région, vous devez créer une configuration personnalisée. Pour

Version53

Amazon GameLift Manuel du développeurIntégration d'un client de jeu

plus de détails sur les noms et les points de terminaison, consultez cette liste de régions AWSprises en charge par GameLift. Si votre client ou service a besoin d'envoyer des demandes pourplusieurs régions, créez un objet de configuration client distinct pour chaque région cible si nécessaire.Consultez Utilisation des régions avec les kits SDK AWS pour obtenir des exemples spécifiques àchaque langage.

2. Initialiser un GameLift client. Appelez Aws::GameLift::GameLiftClient() (C++) en utilisant uneconfiguration de client avec les paramètres par défait ou une configuration personnalisée.

3. Ajoutez un mécanisme permettant de générer un identifiant unique pour chaque joueur. GameLiftexige un ID de joueur unique pour la connexion à une session de jeu. Pour de plus amplesinformations, veuillez consulter Génération d'ID de joueur (p. 57).

4. Collectez et stockez les informations suivantes à utiliser lors de l'établissement du contact avecGameLift :

• Flotte cible – La plupart des demandes d'API GameLift doivent spécifier une flotte, comme pourl'obtention d'informations sur les sessions de jeu disponibles ou la gestion des sessions de jeu etdes sessions de joueur. La façon dont vous définissez la flotte cible optimale (par exemple, définirune flotte statique ou choisir une flotte en fonction de l'emplacement physique d'un appareil). Pourspécifier une flotte cible, utilisez soit un ID de flotte ou un ID d'alias qui pointe vers la flotte cible. Lesalias de flotte sont très utiles. Ils vous permettent en effet d'échanger les joueurs d'une flotte à uneautre sans fournir de mise à jour du client de jeu. La combinaison de la flotte cible et de la région(spécifié dans la configuration du client) identifie la flotte de façon unique.

• File d'attente cible – Si votre jeu utilise des files d'attente composées de plusieurs flottes pour placerde nouvelles sessions de jeu, vous pouvez spécifier la file d'attente à utiliser. Pour spécifier une filed'attente cible, utilisez le nom de la file d'attente. La file d'attente doit être configurée dans la région

• Informations d'identification AWS – Tous les appels au service GameLift doivent fournir lesinformations d'identification du compte AWS qui héberge le jeu. Il s'agit du compte que vous avezutilisé pour configurer vos flottes GameLift, et vous devez avoir créé un utilisateur ou grouped'utilisateurs IAM pour les joueurs avec une stratégie d'autorisations. Vous devez créer un objetAws::Auth::AWSCredentials (C++) contenant une touche d'accès rapide IAM et une clé secrète pourle groupe d'utilisateurs du joueur. Pour obtenir de l'aide sur la recherche de clés, consultez Gestiondes clés d'accès pour les utilisateurs IAM.

Obtention de sessions de jeu

Ajoutez du code pour identifier les sessions de jeu disponibles et gérer les paramètres des sessions de jeuet les métadonnées. Consultez Fonctionnalités d'une session de joueur et d'une session de jeu (p. 13) pouraccéder aux autres fonctions des sessions de jeu.

Recherche de sessions de jeu actives.

Utilisez SearchGameSessions pour obtenir des informations sur une session de jeu spécifique, toutes lessessions actives ou les sessions qui répondent à un ensemble de critères de recherche. Cet appel renvoieun objet GameSession pour chaque session de jeu active qui correspond à votre demande de recherche.

Utilisez des critères de recherche pour obtenir une liste filtrée des sessions de jeu actives auxquelles lesjoueurs peuvent se connecter. Par exemple, vous pouvez filtrer les sessions de la façon suivante :

• Exclure les sessions de jeu qui n'acceptent pas de nouveaux joueurs :PlayerSessionCreationPolicy = DENY_ALL

• Exclure les sessions de jeu qui sont complètes : CurrentPlayerSessionCount =MaximumPlayerSessionCount

• Choisissez les sessions de jeu en fonction de la durée d’exécution de la session : ÉvaluerCreationTime

• Trouver des sessions de jeu en fonction d'une propriété de jeu personnalisée :gameSessionProperties.gameMode = "brawl"

Version54

Amazon GameLift Manuel du développeurIntégration d'un client de jeu

Gestion des sessions de jeu.

Utilisez les opérations suivantes pour récupérer ou mettre à jour des informations sur des sessions de jeu.

• DescribeGameSessionDetails() – Obtenir l'état de protection d'une session de jeu, en plus desinformations sur la session de jeu.

• UpdateGameSession() – Modifier les métadonnées d'une session de jeu et les paramètres en fonction devos besoins.

• GetGameSessionLogUrl – Accéder à des journaux de session de jeu stockés.

Création de sessions de jeu

Ajoutez du code pour démarrer de nouvelles sessions de jeu sur vos flottes déployées et les mettre àdisposition des joueurs. Il existe deux options pour créer des sessions de jeu, selon que vous déployezvotre jeu dans plusieurs régions ou dans une seule région.

Créer une session de jeu à l'aide d'une file d'attente à plusieurs régions.

Utilisez StartGameSessionPlacement pour placer une demande de nouvelle session de jeu dans une filed'attente. Pour utiliser cette fonction, vous devez configurer une file d'attente, qui détermine où (sur quellesflottes) la nouvelle session de jeu peut être placée. Une file d'attente traite une demande de placementde session de jeu en essayant chaque flotte possible, l'une après l'autre, jusqu'à en trouver une ayant lesressources disponibles pour héberger la nouvelle session de jeu. Pour en savoir plus sur les files d'attenteet sur leur utilisation, consultez . Conception d'une file d'attente de session de jeu (p. 143)

Lorsque vous créez une demande de placement de session de jeu, spécifiez le nom de la file d'attente àutiliser, le nom d'une session de jeu, un nombre maximum de joueurs simultanés pour le jeu, ainsi que, sivous le souhaitez, un ensemble de propriétés de jeu. Vous pouvez, si vous le souhaitez, fournir une listede joueurs qui rejoindront automatiquement la session de jeu. Si vous incluez les données de latence desjoueurs pour les régions pertinentes, GameLift utilise ces informations pour placer la nouvelle session dejeu sur une flotte qui fournit la meilleure expérience possible pour les joueurs.

Le placement de session de jeu est un processus asynchrone. Une fois que vous avez lancé unedemande, vous pouvez attendre qu'elle réussisse ou qu'elle expire. Vous pouvez également annuler lademande à tout moment à l'aide de StopGameSessionPlacement. Pour vérifier l'état de votre demande deplacement, appelez DescribeGameSessionPlacement pour récupérer un objet GameSessionPlacementmis à jour. Lorsqu’une nouvelle session de jeu est créée, GameSessionPlacement reflète les modificationssuivantes : (1) Changements de statut de En attente à Terminé ; (2) Ajout de nouvelles informations desession de jeu, y compris l’ID de session de jeu et la région ; et (3) Ajout de nouvelles informations desession de joueur (si demandé).

Création d'une session de jeu sur une flotte spécifique.

Utilisez CreateGameSession pour créer une nouvelle session sur une flotte spécifiée. Cette opérationsynchrone réussit ou échoue selon que la flotte dispose de ressources disponibles pour héberger unenouvelle session de jeu. Votre jeu doit gérer les défaillances de la manière la mieux adaptée à votre jeu etaux joueurs. Par exemple, vous pouvez réitérer la demande jusqu'à ce que des ressources soient libéréesou augmentées, ou changer de flotte. Lorsque GameLift a créé la nouvelle session de jeu et renvoyé unobjet GameSession, vous pouvez commencer à y ajouter des joueurs.

Lorsque vous utilisez cette méthode pour créer une session de jeu, spécifiez un ID de flotte ou un IDd'alias, le nom de la session et le nombre maximum de joueurs simultanés pour le jeu. Vous pouvezégalement inclure un ensemble de propriétés de jeu. Les propriétés de jeu sont définies dans un tableau depaires clé–valeur dans lequel vous définissez les clés et un ensemble de valeurs significatives pour votrejeu. Ces informations sont transmises au processus serveur qui héberge la nouvelle session de jeu, afind'être utilisées dans votre serveur de jeux. Par exemple, vous pouvez utiliser les propriétés de jeu pourindiquer à la session de jeu d'utiliser une carte de jeu spécifique ou un ensemble de règles particulier.

Version55

Amazon GameLift Manuel du développeurIntégration d'un client de jeu

Si vous utilisez la fonction de protection de ressources de GameLift pour limiter le nombre de sessions dejeu qu'un joueur peut créer, vous devrez spécifier l'ID de joueur du créateur de la session de jeu.

Ajout d'un joueur à une session de jeu

Ajoutez du code pour réserver des emplacements de joueurs dans des sessions de jeu actives etconnecter des clients de jeu à des sessions de jeu.

1. Réservez un emplacement de joueur dans une session de jeu.

Pour réserver un emplacement de joueur, créez une session de joueur pour la session de jeu.Consultez Comment les joueurs se connectent aux Jeux (p. 13) pour en savoir plus sur les sessions dejoueur. Vous pouvez créer de nouvelles sessions de joueur de deux façons :

• Si vous utilisez StartGameSessionPlacement pour créer des sessions de jeu, comme décritdans la section précédente, vous pouvez réserver des emplacements pour un ou plusieurs joueursdans la nouvelle session de jeu.

• Réservez des emplacements de joueur pour un ou plusieurs joueurs à l'aide deCreatePlayerSession ou de CreatePlayerSessions avec un ID de session de jeu.

Quelle que soit la méthode utilisée, GameLift commence par vérifier que la session de jeu accepte lesnouveaux joueurs et dispose d'un emplacement de joueur disponible. Si c'est le cas, GameLift réserveun emplacement pour le joueur, crée la nouvelle session de joueur et renvoie un objet PlayerSessioncontenant le nom DNS, l'adresse IP et le port dont le client de jeu a besoin pour se connecter à lasession de jeu.

Une demande de session de joueur doit inclure un ID unique pour chaque joueur. ConsultezGénération d'ID de joueur (p. 57) pour en savoir plus sur les ID de joueur.

Une demande de session de joueur peut également inclure un ensemble de données de joueurpersonnalisées. Ces données sont stockées dans le nouvel objet de session de joueur, qui peut êtrerécupéré à l'aide de DescribePlayerSessions(). Elles sont également transmises du service GameLiftau serveur de jeux lorsque le joueur se connecte directement à la session de jeu. Les données dejoueur ne sont pas utilisées par GameLift. Il s'agit d'une simple chaîne de caractères qui est disponiblepour les composants de votre jeu, à des fins d'interprétation. Lorsque vous demandez plusieurssessions de joueur, vous pouvez fournir une chaîne de données de joueur pour chaque joueur,mappée à l'ID de joueur ID dans la demande.

2. Connectez-vous à une session de jeu.

Ajoutez du code au client de jeu pour récupérer l'objet PlayerSession, qui contient les informationsde connexion de la session de jeu. Utilisez ces informations pour établir une connexion directe auprocessus serveur.

• Vous pouvez vous connecter à l'aide du port spécifié et du nom DNS ou de l'adresse IP attribués auprocessus serveur.

Note

Si la génération de certificats TLS est activée pour vos flottes, vous devez vous connecter àl'aide du nom DNS et du port. Cela est obligatoire même si vous n'avez pas implémenté deprocessus d'authentification serveur.

• Si vous utilisez des ID de session de joueur pour réserver des emplacements de joueur et suivre lesconnexions de joueur, vous devez référencer l'ID de session de joueur.

Une fois connecté, le client de jeu et le processus serveur communiquent directement sansimpliquer le service GameLift pour communiquer le script de jeu. Le processus serveur maintient lacommunication avec le service GameLift pour signaler le statut de connexion du joueur, l'état de santé,

Version56

Amazon GameLift Manuel du développeurIntégration d'un client de jeu

etc. Lors de la connexion initiale, il contacte le service afin de vérifier que l'ID de session de joueurest valide et se trouve dans l'état Reserved. En cas de validation, la réservation est revendiquée et laconnexion du joueur est acceptée. Par la suite, lorsque le joueur se déconnecte, le processus serveurtraite la connexion supprimée.

Si vous souhaitez activer l'authentification du serveur et chiffrer les paquets de données circulant entrele client de jeu et la session de jeu, vous devez créer cette fonctionnalité. Lorsque la fonctionnalitéde génération de certificat TLS est activée pour une nouvelle flotte, GameLift obtient uniquement lecertificat TLS et crée des entrées DNS pour chaque instance de la flotte.

Création de sessions de jeu avec les files d'attenteCet ensemble de fonctions vous permet de placer de nouvelles sessions de jeu plus efficacement sur lesressources Amazon GameLift et de mieux prendre en charge les services de matchmaking. Auparavant,les nouvelles demandes de session de jeu étaient limitées à une seule flotte (CreateGameSession) et lademande échouait si la flotte fonctionnait à pleine capacité ou si elle présentait un quelconque danger.

Utilisez une file d'attente pour placer de nouvelles sessions de jeu sur un groupe de flottes couvrantplusieurs régions. Si besoin, le surplus de demande des joueurs peut être déplacé vers des flottes moinsutilisées dans d'autres régions. Les files d'attente permettent également de diminuer la surcharge liéeau contrôle des flottes et à l'équilibrage des ressources sur plusieurs flottes et plusieurs régions. Vouspouvez gérer les files d'attente et suivre les métriques des performances des files d'attente dans la consoleAmazon GameLift.

Créez une nouvelle demande de placement de session de jeu et ajoutez-la à une file d'attente. Unedemande de placement de session de jeu inclut des propriétés de session de jeu standard. Elle vouspermet aussi d'ajouter un ou plusieurs joueurs à la nouvelle session de jeu.

Lors de la création d'une demande de placement de session de jeu, indiquez les données de latencedes joueurs afin d'aider Amazon GameLift à choisir une flotte dans une région qui fournit la meilleureexpérience possible pour tous les joueurs.

Génération d'ID de joueurLe service GameLift géré utilise une session de joueur pour représenter un joueur connecté à une sessionde jeu. Une session de joueur doit être créée chaque fois qu'un joueur se connecte à une session de jeu.Lorsqu'un joueur quitte un jeu, la session de joueur se termine et n'est pas réutilisée.

GameLift fournit un fichier nommé Lobby.cpp dans l'exemple de projet Amazon Lumberyard MultiplayerSample qui montre comment générer un nouveau numéro d'identification aléatoire pour chaquejoueur dans chaque nouvelle session de jeu. Vous n'êtes pas tenu d'utiliser l'exemple de code ; celui-ciest fourni à titre d'exemple. Vous pouvez également réécrire le code afin de conserver vos propres ID dejoueurs uniques et non identifiables.

L'exemple de code suivant disponible dans Lobby.cpp génère de façon aléatoire des ID de joueuruniques :

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

Vous pouvez consulter les sessions de joueur par ID de joueur dans AWS Management Console pourGameLift. Pour plus d'informations sur les sessions de joueur, consultez Affichage des données sur lessessions de jeu et les sessions de joueur (p. 199).

Version57

Amazon GameLift Manuel du développeurGameLift les interactions

GameLift et interactions client/serveur de jeuCette rubrique décrit les interactions entre un service d’application client, un serveur de jeux et le GameLiftdu service après-vente. Consultez également le diagramme Amazon GameLift – Interactions Game Server/Client (p. 60).

Configuration d’un nouveau processus serveur1. Le service GameLift lance un nouveau processus serveur sur une instance Amazon Elastic Compute

Cloud (Amazon EC2).2. Le processus serveur, dans le cadre du processus de lancement, appelle les actions d’API Server

suivantes :• InitSDK() pour initialiser le kit SDK Server.• ProcessReady() pour communiquer qu'il est prêt à accepter une session de jeu et indiquer une

connexion de port et l'emplacement des fichiers journaux de la session de jeu.

Le processus du serveur attend ensuite un rappel de la part du GameLift du service après-vente.3. Le GameLift service met à jour le statut du processus serveur sur ACTIVE pour permettre le placement

des sessions de jeu avec le processus serveur. (Si le processus serveur est le premier à devenir actifsur une instance, l’état de l’instance est également mis à jour sur ACTIVE.)

4. Le GameLift service commence à appeler le onHealthCheck et continue à l’appeler périodiquementpendant que le processus serveur est actif. Le processus de serveur peut générer un rapport sain ounon sain dans un délai d’une minute.

Création d’une session de jeu1. L'application client appelle l'action d'API Client StartGameSessionPlacement().2. Le GameLift service crée un nouveau GameSessionPlacement avec le statut EN ATTENTE et le

renvoie à l’application cliente demandeuse.3. Le Application client interroge le statut du ticket de placement en appelant périodiquement

DescribeGameSessionPlacement().4. Le GameLift service intitule le placement de session de jeu, en sélectionnant une flotte appropriée et

en recherchant un processus serveur actif dans la flotte avec 0 sessions de jeu. Lorsqu’un processusserveur est localisé, GameLift effectue les opérations suivantes :• Crée un GameSession avec les paramètres de session de jeu et les données de joueur de la

demande de placement et du statut ACTIVATING.• Permet d’appeler le onStartGameSession de rappel sur le processus serveur. Il réussit leGameSession avec des informations dont le processus serveur peut avoir besoin pour configurer lasession de jeu.

• Modifie le nombre de sessions de jeu du processus serveur en 1.5. Le processus serveur exécute la fonction de rappel onStartGameSession. Lorsque vous êtes prêt à

accepter les connexions de joueur, le serveur traite les appels ActivateGameSession() et attend lesconnexions de joueur.

6. Le service GameLift effectue les opérations suivantes :• Met à jour le GameSession objet avec les informations de connexion pour le processus serveur (y

compris le paramètre de port qui a été signalé avec ProcessReady()) et change l’état en ACTIVE.• Met à jour le GameSessionPlacement avec les informations de connexion et définit le statut du

ticket sur FULFILLED.7. Le Application client détecte le statut du ticket mis à jour et peut utiliser les informations de connexion

pour se connecter au processus serveur et rejoindre la session de jeu.Version

58

Amazon GameLift Manuel du développeurGameLift les interactions

Ajout d’un joueur à une session de jeuCette séquence décrit le processus d’ajout d’un joueur à une session de jeu existante. Les sessions dejoueur peuvent également être demandées dans le cadre d’une demande de placement de session de jeu.

1. L'application client appelle l'action d'API Client CreatePlayerSession() avec un ID de session dejeu.

2. Le service GameLift vérifie l'état de la session de jeu (il doit être ACTIVE) et recherche un emplacementde joueur ouvert dans la session de jeu. Si un emplacement est disponible, il effectue les opérationssuivantes :• Il crée un nouvel objet PlayerSession et définit son état sur RESERVED.• Il répond à la demande de l'application client avec l'objet PlayerSession.

3. L'application client se connecte directement au processus serveur avec l'ID session du joueur.4. Le processus serveur appelle l'action d'API Server AcceptPlayerSession() pour valider l'ID de

session du joueur. Si l'ID est validé, le service GameLift transmet l'objet PlayerSession au processusserveur. Le processus serveur accepte ou refuse la connexion.

5. Le service GameLift effectue l'une des opérations suivantes :• Si la connexion est acceptée, elle fait passer la PlayerSession à l'état ACTIVE.• Si aucune réponse n'est reçue dans les 60 secondes de l'appel CreatePlayerSession() d'origine

de l'application client, il fait passer la PlayerSession à l'état TIMEDOUT et rouvre l'emplacement dejoueur dans la session de jeu.

Suppression d’un joueur d’une session de jeu1. L'application client se déconnecte du processus serveur.2. Le processus serveur détecte la connexion perdue et appelle l'action d'API Server

RemovePlayerSession().3. Le service GameLift fait passer PlayerSession à l'état COMPLETED (TERMINÉ) et rouvre

l'emplacement de joueur dans la session de jeu.

Arrêt d'une session de jeuCette séquence est utilisée lorsqu’un processus serveur met fin à la session de jeu en cours se terminantelle-même.

1. Le processus serveur effectue les opérations suivantes :• Exécute le code pour arrêter correctement la session de jeu et le processus serveur.• Il appelle l'action d'API ProcessEnding() pour informer le service GameLift.

2. Le service GameLift effectue les opérations suivantes :• Il charge les journaux de session de jeu dans Amazon Simple Storage Service (Amazon S3).• Il fait passer la GameSession à l'état TERMINATED.• Il fait passer le processus serveur à l'état TERMINATED.• Il recycle les ressources d'instance en fonction de la configuration d'exécution de la flotte.

Répondre à une demande d’arrêtCette séquence est utilisée par le GameLift pour forcer un processus serveur à arrêter. Cette actionpeut être effectuée pour mettre fin à un processus non sain ou pour arrêter un processus en douceur

Version59

Amazon GameLift Manuel du développeurGameLift les interactions

lorsque l’instance sur laquelle le processus est en cours d’arrêt, par exemple lors de la mise à l’échelleautomatique. Elle peut également être utilisée lors de la gestion d’une interruption d’instance Spot.

1. Le service GameLift appelle le rappel onProcessTerminate du processus serveur.2. Le processus serveur exécute le onProcessTerminate fonction de rappel, qui déclenche la séquence

de fin du processus, se terminant par un appel à ProcessEnding().3. Le service GameLift effectue les opérations suivantes, en réponse à la réception de l'appel

ProcessEnding() ou au bout de cinq minutes :• Si une session de jeu était en cours, charge les journaux de session de jeu (le cas échéant) sur

Amazon S3 et modifie le GameSession sur TERMINATED.• Il fait passer le processus serveur à l'état TERMINATED.• Il recycle les ressources d'instance en fonction de la configuration d'exécution de la flotte.

Amazon GameLift – Interactions Game Server/ClientLe diagramme ci-dessous décrit les interactions de l'API qui se produisent lors de la gestion de tâches desession de jeu multijoueur à l'aide de la solution GameLift gérée.

Version60

Amazon GameLift Manuel du développeurTest de l'intégration

Test de l'intégrationUtilisez GameLift Local pour exécuter une version limitée du service GameLift géré sur un périphériquelocal et tester l'intégration de votre jeu par rapport à cette version. Cet outil est utile lors de l'exécution d'undéveloppement itératif sur l'intégration de votre jeu. L'autre solution, à savoir charger chaque nouvelle buildsur GameLift et configurer une flotte pour héberger votre jeu, peut prendre au moins 30 minutes à chaquefois.

Avec GameLift Local, vous pouvez vérifier les points suivants :

Version61

Amazon GameLift Manuel du développeurTest de l'intégration

• Votre serveur de jeux est correctement intégré au kit SDK Server et communique correctement avec leservice GameLift pour démarrer de nouvelles sessions de jeu, accepter de nouveaux joueurs, ainsi querendre compte de l'intégrité et de l'état.

• Votre client de jeu est correctement intégré au kit de développement logiciel (SDK) AWS pour GameLiftet peut récupérer des informations sur les sessions de jeu existantes, démarrer de nouvelles sessions dejeu, joindre des joueurs à des jeux et se connecter à la session de jeu.

GameLift Local est un outil de ligne de commande qui lance une version autonome du service GameLiftgéré. GameLift Local fournit également un journal des événements en cours concernant l'initialisation duprocessus serveur, des vérifications de l'état, ainsi que des appels d'API et de leurs réponses. GameLiftLocal identifie un sous-ensemble des actions du kit SDK AWS pour GameLift. Les appels peuvent êtreeffectués à partir de l'AWS CLI ou de votre client de jeu. Toutes les actions d'API s'exécutent localement dela même manière que dans le service web GameLift.

Configuration de GameLift LocalGameLift Local est fourni sous la forme d'un fichier exécutable .jar accompagné du kit SDK Server. Ilpeut s'exécuter sous Windows ou Linux, et être utilisé avec tout langage pris en charge par GameLift.

Avant d'exécuter Local, les éléments suivants doivent avoir été installés.

• Une build de la version 3.1.5 du kit SDK Server GameLift ou version supérieure• Java 8

Test d'un serveur de jeuxSi vous souhaitez tester uniquement votre serveur de jeux, vous pouvez utiliser l'AWS CLI pour simuler lesappels du client de jeu en direction du service GameLift Local. Vous pouvez ainsi vérifier que votre serveurde jeux se comporte comme prévu dans les circonstances suivantes :

• Le serveur de jeux lance correctement le kit SDK Server GameLift et l'initialise.• Dans le cadre du processus de lancement, le serveur de jeux informe GameLift que le serveur est prêt à

héberger des sessions de jeu.• Le serveur de jeux envoie le l'état d'intégrité à GameLift toutes les minutes pendant l'exécution.• Le serveur de jeux répond aux demandes de démarrage d'une nouvelle session de jeu.

1. Démarrez GameLift Local.

Ouvrez une fenêtre d'invite de commande, accédez au répertoire contenant le fichierGameLiftLocal.jar et exécutez-le. Par défaut, Local écoute les demandes des clients de jeu surle port 8080. Pour spécifier un autre numéro de port, utilisez le paramètre -p, comme indiqué dansl'exemple suivant:

java -jar GameLiftLocal.jar -p 9080

Une fois que Local a démarré, les journaux indiquent que deux serveurs locaux ont été lancés, l'unqui écoute votre serveur de jeux et l'autre qui écoute votre client de jeu ou l'AWS CLI. Les journauxcontinuent de signaler l'activité sur les deux serveurs locaux, y compris la communication vers etdepuis les composants de votre jeu.

2. Démarrez votre serveur de jeux.

Démarrez localement votre serveur de jeux intégré à GameLift. Il n'est pas nécessaire de modifier lepoint de terminaison du serveur de jeux.

Version62

Amazon GameLift Manuel du développeurTest de l'intégration

Dans la fenêtre d'invite de commande Local, les messages des journaux indiquent que votre serveurde jeux s'est connecté au service GameLift Local. Cela signifie que votre serveur de jeux a initialiséavec succès le kit SDK Server GameLift (avec InitSDK()). Il a appelé ProcessReady() avecles chemins d'accès aux journaux affichés et, en cas de succès, est prêt à héberger une session dejeu. Tandis que le serveur de jeux s'exécute, GameLift enregistre chaque rapport d'état d'intégrité duserveur de jeux. L'exemple de message de journal suivant illustre l'intégration réussie d'un serveur dejeux :

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

Les messages éventuels d'erreur ou d'avertissement sont les suivants :

• Erreur : « ProcessReady did not find a process with pID: <process ID>! Was InitSDK()invoked? (ProcessReady n'a pas trouvé de processus avec l'ID : <replaceable><ID processus></replaceable> ! InitSDK() a-t-il été appelé ?) »

• Avertissement : « Process state already exists for process with pID: <process ID>! IsProcessReady(...) invoked more than once? (Cet état existe déjà pour le processus portant l'ID :<replaceable><ID processus></replaceable> ! ProcessReady(...) a-t-il été appelé plusieurs fois ?) »

3. Démarrez l'AWS CLI.

Une fois que votre serveur de jeux a appelé ProcessReady() avec succès, vous pouvez démarrerles appels clients. Ouvrez une autre fenêtre d'invite de commande et démarrez l'AWS CLI. Obtenezet installez l'outil AWS Command Line Interface. Par défaut, l'AWS CLI utilise le point de terminaisondu service web GameLift. Vous devez remplacer celui-ci par le point de terminaison Local dans toutesles demandes à l'aide du paramètre --endpoint-url, comme indiqué dans l'exemple de demandesuivant.

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

Dans la fenêtre d'invite de commande de l'AWS CLI, les commandes aws gamelift entraînent desréponses, comme documenté dans la AWS CLI Command Reference.

4. Créez une session de jeu.

Avec l'AWS CLI, envoyez une demande CreateGameSession(). La demande doit respecter la syntaxeattendue. Pour Local, le paramètre FleetId peut être défini avec toute chaîne valide (^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

Version63

Amazon GameLift Manuel du développeurTest de l'intégration

Dans la fenêtre d'invite de commande Local, les messages du journal indiquent que GameLift Local aenvoyé à votre serveur de jeux un rappel onStartGameSession. Si une session de jeu a été crééeavec succès, votre serveur de jeux répond en appelant ActivateGameSession.

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"

Dans la fenêtre de l'AWS CLI, GameLift répond avec un objet de session de jeu incluant un ID desession de jeu. Notez que le statut de la nouvelle session de jeu est Activating. Le statut devient Active(Actif) une fois que votre serveur de jeu appelle ActivateGameSession. Si vous souhaitez voir le statutmodifié, utilisez l'AWS CLI pour appeler 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 }}

Test d'un serveur de jeux et d'un client de jeuPour vérifier l'intégration complète de votre jeu, y compris la connexion de joueurs à des parties, vouspouvez exécuter votre serveur de jeux et votre client de jeu localement. Vous pouvez ainsi tester les appelspar programmation de votre client de jeu vers GameLift Local. Vous pouvez vérifier les actions suivantes :

• Le client de jeu exécute avec succès les demandes du kit SDK AWS adressées au service GameLiftLocal, y compris celles de création de sessions de jeu, de récupération d'informations sur les sessions dejeu existantes et de création de sessions de joueur.

• Le serveur de jeux valide correctement les joueurs lorsqu'ils tentent de rejoindre une session de jeu.Pour les joueurs validés, le serveur de jeux peut récupérer les données des joueurs (si la fonction a étémise en œuvre).

• Le serveur de jeux signale l'abandon d'une connexion quand un joueur quitte le jeu.• Le serveur de jeux rapporte la fin d'une session de jeu.

1. Démarrez GameLift Local.

Version64

Amazon GameLift Manuel du développeurTest de l'intégration

Ouvrez une fenêtre d'invite de commande, accédez au répertoire contenant le fichierGameLiftLocal.jar et exécutez-le. Par défaut, Local écoute les demandes des clients de jeu surle port 8080. Pour spécifier un autre numéro de port, utilisez le paramètre -p, comme indiqué dansl'exemple suivant.

./gamelift-local -p 9080

Une fois que Local a démarré, vous voyez que les journaux affichent le lancement de deux serveurslocaux, l'un qui écoute votre serveur de jeux et l'autre qui écoute votre client de jeu ou l'AWS CLI.

2. Démarrez votre serveur de jeux.

Démarrez localement votre serveur de jeux intégré à GameLift. Pour plus d'informations sur lesjournaux de messages, consultez Test d'un serveur de jeux (p. 62).

3. Configurez votre client de jeu pour Local et démarrez-le.

Pour utiliser votre client de jeu avec le service GameLift Local, vous devez apporter les modificationssuivantes à la configuration de votre client de jeu, comme décrit dans Configuration de GameLift sur unclient ou un service (p. 53) :

• Modifiez l'objet ClientConfiguration afin de pointer vers votre point de terminaison Local, telque http://localhost:9080.

• Définissez une valeur d'ID de flotte cible. Pour Local, vous n'avez pas besoin d'un ID de flotteréel ; définissez la flotte cible avec une chaîne valide de votre choix (^fleet-\S+), commefleet-1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d.

• Définissez les informations d'identification AWS. Pour Local, vous n'avez pas besoin d'informationsd'identification AWS réelles ; vous pouvez définir la clé d'accès et la clé secrète avec toute chaîne devotre choix.

Dans la fenêtre d'invite de commande Local, une fois que vous avez démarré le client de jeu, lesmessages de journal doivent indiquer qu'il a initialisé le client GameLiftClient et qu'il communiquecorrectement avec le service GameLift.

4. Testez les appels de clients de jeu adressés au service GameLift.

Vérifiez que votre client de jeu effectue correctement tout ou partie des appels d'API suivants :

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

Dans la fenêtre d'invite de commande Local, seuls les appels à CreateGameSession() se traduisentpar des messages de journaux. Les messages de journal s'affichent quand GameLift Local invitevotre serveur de jeux à démarrer une session de jeu (rappel onStartGameSession) et obtient avecsuccès un message ActivateGameSession lorsque votre serveur de jeux l'appelle. Dans la fenêtrede l'AWS CLI, tous les appels d'API entraînent des réponses ou des messages d'erreur tels quedocumentés.

5. Vérifiez que votre serveur de jeux valide les nouvelles connexions de joueur.

Après avoir créé une session de jeu et une session joueur, établissez une connexion directe à lasession de jeu.

Version65

Amazon GameLift Manuel du développeurIntégration de jeux avec Serveurs en temps réel

Dans la fenêtre d'invite de commande Local, les messages de journaux doivent indiquer que le serveurde jeux a envoyé une demande AcceptPlayerSession() pour valider la nouvelle connexion dejoueur. Si vous utilisez l'AWS CLI pour appeler DescribePlayerSessions(), l'état de la session dejoueur doit passer d'Instances réservées à Actif.

6. Vérifiez que votre serveur de jeux signale l'état du jeu et celui du joueur au service GameLift.

Pour que GameLift puisse gérer la demande des joueurs et rapporter correctement les métriques,votre serveur de jeux doit signaler différents états à GameLift. Vérifiez que Local enregistre lesévénements liés aux actions suivantes. Vous pouvez également utiliser l'AWS CLI pour suivre leschangements d'état.

• Le joueur se déconnecte d'une session de jeu – Les messages de journal GameLift Local doiventindiquer que votre serveur de jeux appelle RemovePlayerSession(). Un appel de l'AWS CLI àDescribePlayerSessions() doit refléter un changement d'état d'Active en Completed. Vouspouvez également appeler DescribeGameSessions() pour vérifier que le nombre de joueurs encours de la session a diminué d'une unité.

• La session de jeu se termine – Les messages de journal GameLift Local doivent indiquerque votre serveur de jeux appelle TerminateGameSession(). Un appel de l'AWS CLI àDescribeGameSessions() doit refléter un changement d'état d'Active en Terminated (ouTerminating).

• Le processus serveur est terminé – Les messages de journal GameLift Local doivent indiquer quevotre serveur de jeux appelle ProcessEnding().

Différences avec LocalLorsque vous utilisez GameLift Local, gardez à l'esprit les points suivants :

• Contrairement au service web, GameLift Local ne permet pas de suivre l'état d'intégrité d'un serveur etd'initier le rappel onProcessTerminate. Local arrête simplement la journalisation des rapports d'étatpour le serveur de jeux.

• Pour les appels vers le kit SDK AWS, les ID de flotte ne sont pas validés et peuvent être n'importe quellevaleur de chaîne qui répond aux exigences du paramètre (^fleet-\S+).

• Les ID de session de jeu créés avec Local ont une structure différente. Ils incluent la chaîne local,comme illustré ici :

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

Intégration de jeux avec Amazon GameLiftServeurs en temps réel

Amazon GameLift Serveurs en temps réel offre une solution de serveur léger conçue pour les jeux qui n'ontpas besoin d'un serveur de jeu complexe, créé sur mesure. Des jeux comme des jeux mobiles, des jeux autour par tour, des jeux basés sur des messages, etc., peuvent utiliser des serveurs de jeu RealTime prêtsà l'emploi qui nécessitent une configuration minimale tout en pouvant être personnalisés avec une logiquespécifique de jeu.

Conseil

Informez-vous sur les façons d'explorer les fonctions Amazon GameLift, en particulier Serveurs entemps réel, à l'aide des exemples de jeux. (p. 32).

Version66

Amazon GameLift Manuel du développeurIntégration d'un client de jeu

Les rubriques de cette section décrivent la façon d'activer vos clients de jeu multijoueur pour vousconnecter et utiliser des serveurs de jeu Serveurs en temps réel qui s'exécutent sur GameLift. Pour obtenirune feuille de route complète afin de rendre votre jeu opérationnel avec Serveurs en temps réel, veuillezconsulter Premiers pas avec Serveurs en temps réel (p. 35).

Consultez les liens ci-dessous pour en savoir plus sur Serveurs en temps réel :

• Fonctionnement des Serveurs en temps réel (p. 9)

Commencez l'intégration de votre jeu avec Serveurs en temps réel :• Intégration d'un client de jeu pour Serveurs en temps réel (p. 67)• Création d'un script RealTime (p. 71)

• Premiers pas avec Serveurs en temps réel (p. 35)

Intégration d'un client de jeu pour Serveurs en tempsréelCette rubrique décrit comment préparer votre client de jeu à rejoindre et participer à des sessions de jeuhébergées par Amazon GameLift.

Il existe deux ensembles de tâches nécessaires pour préparer votre client de jeu :

• Configurer votre client de jeu pour obtenir plus d'informations sur des jeux existants, demander la miseen relation, démarrer de nouvelles sessions de jeu et réserver des emplacements de session de jeu pourun joueur.

• Permettez à votre client de jeu de rejoindre une session de jeu hébergée sur un serveur RealTime etd'échanger des messages.

Trouvez ou créez des sessions de jeu et de joueursConfigurez votre client de jeu pour trouver ou démarrer des sessions de jeu, demander des mises enrelation FlexMatch et réserver de l'espace pour les joueurs dans un jeu en créant des sessions de joueur.Une bonne pratique consiste à créer un service client et à l'utiliser pour effectuer des demandes directes auservice Amazon GameLift lorsqu'il est déclenché par une action de client de jeu. Le service client transmetensuite les réponses correspondantes au client de jeu.

1. Ajoutez le kit SDK AWS à votre projet de service client, initialisez un client Amazon GameLift etconfigurez-le pour utiliser les ressources d'hébergement dans vos flottes et/ou files d'attente. Le AWSSDK est disponible dans plusieurs langues ; consultez les kits SDK Amazon GameLift Pour les servicesà la clientèle (p. 28).

2. Ajoutez les fonctionnalités GameLift à votre service client. Pour des instructions plus détaillées,consultez Ajout d'Amazon GameLift à votre client de jeu (p. 53) et Ajout en cours de mise en relationFlexMatch (p. 77). Une bonne pratique consiste à utiliser des placements de session de jeu pourcréer de nouvelles sessions de jeu. Cette méthode vous permet de tirer pleinement profit de la capacitéde GameLift à placer intelligemment et rapidement de nouvelles sessions de jeu, ainsi qu'à utiliser lesdonnées de latence des joueurs pour minimiser les retards de jeu. Au minimum, votre service client doitêtre en mesure de demander de nouvelles sessions de jeu et de gérer les données de session de jeu enréponse. Vous pouvez également ajouter des fonctionnalités pour rechercher et obtenir des informationssur les sessions de jeu existantes, et demander des sessions de joueur qui réservent de façon efficaceun emplacement de joueur dans une session de jeu existante.

Version67

Amazon GameLift Manuel du développeurIntégration d'un client de jeu

3. Renvoyer des informations de connexion vers le client de jeu. Le service de jeu en backend reçoit lesobjets de session de jeu et de joueur en réponse à des demandes au service Amazon GameLift. Cesobjets contiennent des informations, notamment les détails de connexion (adresse IP et port) et l'ID desession du joueur, dont le client de jeu a besoin pour se connecter à la session de jeu en cours sur unserveur en temps réel.

Connectez-vous aux jeux sur Serveurs en temps réelAutorisez votre client de jeu à se connecter directement à une session de jeu hébergée sur un serveurRealTime et d'échanger des messagers avec le serveur et d'autres joueurs.

1. Obtenez le kit SDK de client RealTime, créez-le, puis ajoutez-le à votre projet de client de jeu. Consultezle fichier README pour plus d'informations sur les exigences du kit SDK et des instructions sur la façonde créer les bibliothèques client.

2. Appelez Client() (p. 270) avec une configuration client qui spécifie le type de connexion client/serveur àutiliser.

Note

Si vous vous connectez à un serveur en temps réel qui s'exécute sur une flotte sécurisée avecun certificat TLS, vous devez spécifier un type de connexion sécurisé.

3. Ajoutez les fonctionnalités suivantes à votre client de jeu. Consultez la Référence d'API de clientServeurs en temps réel (C#) (p. 270) pour plus d'informations.• Se connecter et se déconnecter d'un jeu

• Connect() (p. 271)• Disconnect() (p. 272)

• Envoyer des messages à des destinataires cibles• SendMessage() (p. 273)

• Recevoir et traiter des messages• OnDataReceived() (p. 276)

• Rejoindre des groupes et quitter des groupes de joueurs• JoinGroup() (p. 273)• RequestGroupMembership() (p. 274)• LeaveGroup() (p. 273)

4. Configuration des gestionnaires d'événements pour les rappels de client en fonction de vos besoins. VoirRéférence d'API de client (C#) Serveurs en temps réel : Rappels asynchrones (p. 274).

Lorsque vous travaillez avec des flottes en temps réel pour lesquelles la génération de certificats TLS estactivée, le serveur est automatiquement authentifié à l'aide du certificat TLS. Le trafic TCP et UDP estchiffré en transit pour assurer la sécurité de la couche de transport. Le trafic TCP est chiffré avec TLS 1.2et le trafic UDP avec DTLS 1.2.

Exemples de client de jeuClient en temps réel de base (C#)Cet exemple illustre une intégration de client de jeu basique avec le kit SDK de client RealTime (C#).Comme cela est illustré, l'exemple initialise un objet de client RealTime, configure des gestionnairesd'événements et met en œuvre les rappels côté client, se connecte à un serveur RealTime, envoie unmessage et se déconnecte.

using System;using System.Text;

Version68

Amazon GameLift Manuel du développeurIntégration d'un client de jeu

using Aws.GameLift.Realtime;using Aws.GameLift.Realtime.Event;using Aws.GameLift.Realtime.Types;

namespace Example{ /** * An example client that wraps the GameLift Realtime client SDK * * You can redirect logging from the SDK by setting up the LogHandler as such: * ClientLogger.LogHandler = (x) => Console.WriteLine(x); * */ class RealTimeClient { public Aws.GameLift.Realtime.Client Client { get; private set; } // An opcode defined by client and your server script that represents a custom message type private const int MY_TEST_OP_CODE = 10;

/// Initialize a client for GameLift Realtime and connect to a player session. /// <param name="endpoint">The DNS name that is assigned to Realtime server</param> /// <param name="remoteTcpPort">A TCP port for the Realtime server</param> /// <param name="listeningUdpPort">A local port for listening to UDP traffic</param> /// <param name="connectionType">Type of connection to establish between client and the Realtime server</param> /// <param name="playerSessionId">The player session ID that is assigned to the game client for a game session </param> /// <param name="connectionPayload">Developer-defined data to be used during client connection, such as for player authentication</param> public RealTimeClient(string endpoint, int remoteTcpPort, int listeningUdpPort, ConnectionType connectionType, string playerSessionId, byte[] connectionPayload) { // Create a client configuration to specify a secure or unsecure connection type // Best practice is to set up a secure connection using the connection type RT_OVER_WSS_DTLS_TLS12. ClientConfiguration clientConfiguration = new ClientConfiguration() { // C# notation to set the field ConnectionType in the new instance of ClientConfiguration ConnectionType = connectionType };

// Create a Realtime client with the client configuration Client = new Client(clientConfiguration);

// Initialize event handlers for the Realtime client Client.ConnectionOpen += OnOpenEvent; Client.ConnectionClose += OnCloseEvent; Client.GroupMembershipUpdated += OnGroupMembershipUpdate; Client.DataReceived += OnDataReceived;

// Create a connection token to authenticate the client with the Realtime server // Player session IDs can be retrieved using AWS SDK for GameLift ConnectionToken connectionToken = new ConnectionToken(playerSessionId, connectionPayload);

// Initiate a connection with the Realtime server with the given connection information Client.Connect(endpoint, remoteTcpPort, listeningUdpPort, connectionToken); }

Version69

Amazon GameLift Manuel du développeurIntégration d'un client de jeu

public void Disconnect() { if (Client.Connected) { Client.Disconnect(); } }

public bool IsConnected() { return Client.Connected; }

/// <summary> /// Example of sending to a custom message to the server. /// /// Server could be replaced by known peer Id etc. /// </summary> /// <param name="intent">Choice of delivery intent ie Reliable, Fast etc. </param> /// <param name="payload">Custom payload to send with message</param> public void SendMessage(DeliveryIntent intent, string payload) { Client.SendMessage(Client.NewMessage(MY_TEST_OP_CODE) .WithDeliveryIntent(intent) .WithTargetPlayer(Constants.PLAYER_ID_SERVER) .WithPayload(StringToBytes(payload))); }

/** * Handle connection open events */ public void OnOpenEvent(object sender, EventArgs e) { }

/** * Handle connection close events */ public void OnCloseEvent(object sender, EventArgs e) { }

/** * Handle Group membership update events */ public void OnGroupMembershipUpdate(object sender, GroupMembershipEventArgs e) { }

/** * Handle data received from the Realtime server */ public virtual void OnDataReceived(object sender, DataReceivedEventArgs e) { switch (e.OpCode) { // handle message based on OpCode default: break; } }

/** * Helper method to simplify task of sending/receiving payloads. */

Version70

Amazon GameLift Manuel du développeurPersonnalisation d'un script RealTime

public static byte[] StringToBytes(string str) { return Encoding.UTF8.GetBytes(str); }

/** * Helper method to simplify task of sending/receiving payloads. */ public static string BytesToString(byte[] bytes) { return Encoding.UTF8.GetString(bytes); } }}

Création d'un script RealTimePour utiliser des Serveurs en temps réel pour votre jeu, vous devez fournir un script (sous la forme decode JavaScript) pour configurer et éventuellement personnaliser une flotte de Serveurs en temps réel.Cette rubrique explique les principales étapes de la création d'un script RealTime. Une fois que le script estprêt, chargez-le dans le service Amazon GameLift et utilisez-le pour créer une flotte (voir Chargement d'unServeurs en temps réel script dansGameLift (p. 107)).

Pour préparer un script à utiliser avec des Serveurs en temps réel, ajoutez les fonctionnalités suivantes àvotre script RealTime.

Gestion du cycle de vie des sessions de jeu (obligatoire)Au minimum, un script RealTime doit inclure la fonction Init(), qui prépare le serveur RealTime pourcommencer une session de jeu. Il est également vivement recommandé de fournir un moyen de mettre finà des sessions de jeu, afin de garantir que de nouvelles sessions de jeu pourront être encore démarréessur votre flotte.

La fonction de rappel Init(), lorsqu'elle est appelée, se voit transmettre un objet de session RealTime,qui contient une interface pour le serveur RealTime. Veuillez consulter Interface Serveurs en tempsréel (p. 282) pour plus de détails sur cette interface.

Pour mettre fin élégamment à une session de jeu, le script doit également appeler la fonctionsession.processEnding du serveur RealTime. Cela requiert un mécanisme pour déterminer quandmettre fin à une session. L'exemple de code de script illustre un mécanisme simple qui recherche lesconnexions de joueur et déclenche l'arrêt de la session de jeu quand aucun joueur ne s'est connecté à lasession depuis un temps spécifié.

Les Serveurs en temps réel avec la configuration la plus élémentaire (initialisation et arrêt des processusserveur) agissent essentiellement comme des serveurs de relais sans état. Le serveur RealTime relaie lesmessages et les données de jeu entre les clients de jeu connectés au jeu, mais ne prend aucune mesureindépendante pour traiter les données ou exécuter la logique. Vous pouvez également ajouter une logiquede jeu, déclenchée par des événements de jeu ou d'autres mécanismes, en fonction des besoins de votrejeu.

Ajout d'une logique de jeu côté serveur (facultatif)Si vous le souhaitez, vous pouvez ajouter une logique de jeu à votre script RealTime. Vous pouvez,par exemple, effectuer une partie ou l'ensemble des opérations suivantes. L'exemple de code de scriptfournit une illustration. Veuillez consulter Référence des scripts des Serveurs en temps réel AmazonGameLift (p. 280).

• Ajoutez une logique pilotée par les événements. Implémentez les fonctions de rappel pour répondre auxévénements client-serveur. Veuillez consulter

Version71

Amazon GameLift Manuel du développeurPersonnalisation d'un script RealTime

Vous pouvez fournir une logique personnalisée pour répondre à des événements enmettant en œuvre ces rappels dans votre script RealTime.

init

Initialise le serveur RealTime et reçoit une interface de serveur en temps réel.

Syntaxe

init(rtsession)

onMessage

Appelé lorsqu'un message reçu est envoyé au serveur.

Syntaxe

onMessage(gameMessage)

onHealthCheck

Appelé pour définir le statut d'intégrité de la session de jeu. Par défaut, le statut d'intégritéest sain (ou true). Ce rappel peut être implémenté pour effectuer des vérifications de l'étatpersonnalisées et renvoyer un statut.

Syntaxe

onHealthCheck()

onStartGameSession

Appelé lorsqu'une nouvelle session de jeu démarre, avec un objet de session de jeutransmis.

Syntaxe

onStartGameSession(session)

onProcessTerminate

Appelé lorsque le processus serveur est en cours de résiliation par le service AmazonGameLift. Il peut agir comme déclencheur pour quitter de façon nette la session de jeu. Iln'y a pas besoin d'appeler processEnding().

Syntaxe

onProcessTerminate()

onPlayerConnect

Appelé lorsqu'un joueur demande une connexion et a réussi la validation initiale.

Version72

Amazon GameLift Manuel du développeurPersonnalisation d'un script RealTime

Syntaxe

onPlayerConnect(connectMessage)

onPlayerAccepted

Appelé lorsqu'une connexion de joueur est acceptée.

Syntaxe

onPlayerAccepted(player)

onPlayerDisconnect

Appelé lorsqu'un joueur se déconnecte de la session de jeu, que ce soit en envoyant unedemande de déconnexion ou par d'autres moyens.

Syntaxe

onPlayerDisconnect(peerId)

onProcessStarted

Appelé lorsqu'un processus serveur est démarré. Ce rappel autorise le script à effectuertoutes les tâches personnalisées nécessaires pour préparer l'hébergement d'une sessionde jeu.

Syntaxe

onProcessStarted(args)

onSendToPlayer

Appelé lorsqu'un message est reçu sur le serveur d'un joueur pour être livré à un autrejoueur. Ce processus s'exécute avant que le message soit livré.

Syntaxe

onSendToPlayer(gameMessage)

onSendToGroup

Appelé lorsqu'un message est reçu sur le serveur d'un joueur pour être livré à un groupe.Ce processus s'exécute avant que le message soit livré.

Syntaxe

onSendToGroup(gameMessage))

onPlayerJoinGroup

Appelé lorsqu'un joueur envoie une demande pour rejoindre un groupe.

Version73

Amazon GameLift Manuel du développeurPersonnalisation d'un script RealTime

Syntaxe

onPlayerJoinGroup(groupId, peerId)

onPlayerLeaveGroup

Appelé lorsqu'un joueur envoie une demande pour quitter un groupe.

Syntaxe

onPlayerLeaveGroup(groupId, peerId)

(p. 280) pour obtenir la liste complète des rappels.• Déclenchez la logique en envoyant des messages au serveur. Créez un ensemble de codes d'opération

spéciaux pour les messages envoyés au serveur à partir des clients de jeu et ajoutez des fonctionspour gérer leur réception. Utilisez le rappel onMessage et analysez le contenu du message à l'aide del'interface gameMessage (voir gameMessage.opcode (p. 285)).

• Activez la logique de jeu pour accéder à vos autres ressources AWS. Pour de plus amples informations,veuillez consulter Communiquez avec d’autres ressources AWS de vos flottes (p. 49).

• Permet à la logique de jeu d’accéder aux informations de parc pour l’instance qu’elle exécute sur.Pour de plus amples informations, veuillez consulter Obtenir des données de flotte pour un GameLiftinstance (p. 51).

Exemple de script de Serveurs en temps réelCet exemple illustre un script élémentaire requis pour déployer des Serveurs en temps réel et une logiquepersonnalisée. Il contient la fonction Init() requise et utilise une minuterie pour déclencher l'arrêt de lasession de jeu en fonction du temps écoulé sans connexion de joueur. Il inclut également des hooks pourune logique personnalisée, y compris certaines implémentations de rappel.

// Example Realtime Server Script'use strict';

// Example override configurationconst configuration = { pingIntervalTime: 30000};

// Timing mechanism used to trigger end of game session. Defines how long, in milliseconds, between each tick in the example tick loopconst tickTime = 1000;

// Defines how to long to wait in Seconds before beginning early termination check in the example tick loopconst minimumElapsedTime = 120;

var session; // The Realtime server session objectvar logger; // Log at appropriate level via .info(), .warn(), .error(), .debug()var startTime; // Records the time the process startedvar activePlayers = 0; // Records the number of connected playersvar onProcessStartedCalled = false; // Record if onProcessStarted has been called

// Example custom op codes for user-defined messages// Any positive op code number can be defined here. These should match your client code.const OP_CODE_CUSTOM_OP1 = 111;

Version74

Amazon GameLift Manuel du développeurPersonnalisation d'un script RealTime

const OP_CODE_CUSTOM_OP1_REPLY = 112;const OP_CODE_PLAYER_ACCEPTED = 113;const OP_CODE_DISCONNECT_NOTIFICATION = 114;

// Example groups for user defined groups// Any positive group number can be defined here. These should match your client code.const RED_TEAM_GROUP = 1;const BLUE_TEAM_GROUP = 2;

// Called when game server is initialized, passed server's object of current sessionfunction init(rtSession) { session = rtSession; logger = session.getLogger();}

// On Process Started is called when the process has begun and we need to perform any// bootstrapping. This is where the developer should insert any code to prepare// the process to be able to host a game session, for example load some settings or set state//// Return true if the process has been appropriately prepared and it is okay to invoke the// GameLift ProcessReady() call.function onProcessStarted(args) { onProcessStartedCalled = true; logger.info("Starting process with args: " + args); logger.info("Ready to host games...");

return true;}

// Called when a new game session is started on the processfunction onStartGameSession(gameSession) { // Complete any game session set-up

// Set up an example tick loop to perform server initiated actions startTime = getTimeInS(); tickLoop();}

// Handle process termination if the process is being terminated by GameLift// You do not need to call ProcessEnding herefunction onProcessTerminate() { // Perform any clean up}

// Return true if the process is healthyfunction onHealthCheck() { return true;}

// On Player Connect is called when a player has passed initial validation// Return true if player should connect, false to rejectfunction onPlayerConnect(connectMsg) { // Perform any validation needed for connectMsg.payload, connectMsg.peerId return true;}

// Called when a Player is accepted into the gamefunction onPlayerAccepted(player) { // This player was accepted -- let's send them a message const msg = session.newTextGameMessage(OP_CODE_PLAYER_ACCEPTED, player.peerId, "Peer " + player.peerId + " accepted"); session.sendReliableMessage(msg, player.peerId); activePlayers++;}

Version75

Amazon GameLift Manuel du développeurPersonnalisation d'un script RealTime

// On Player Disconnect is called when a player has left or been forcibly terminated// Is only called for players that actually connected to the server and not those rejected by validation// This is called before the player is removed from the player listfunction onPlayerDisconnect(peerId) { // send a message to each remaining player letting them know about the disconnect const outMessage = session.newTextGameMessage(OP_CODE_DISCONNECT_NOTIFICATION, session.getServerId(), "Peer " + peerId + " disconnected"); session.getPlayers().forEach((player, playerId) => { if (playerId != peerId) { session.sendReliableMessage(outMessage, peerId); } }); activePlayers--;}

// Handle a message to the serverfunction onMessage(gameMessage) { switch (gameMessage.opCode) { case OP_CODE_CUSTOM_OP1: { // do operation 1 with gameMessage.payload for example sendToGroup const outMessage = session.newTextGameMessage(OP_CODE_CUSTOM_OP1_REPLY, session.getServerId(), gameMessage.payload); session.sendGroupMessage(outMessage, RED_TEAM_GROUP); break; } }}

// Return true if the send should be allowedfunction onSendToPlayer(gameMessage) { // This example rejects any payloads containing "Reject" return (!gameMessage.getPayloadAsText().includes("Reject"));}

// Return true if the send to group should be allowed// Use gameMessage.getPayloadAsText() to get the message contentsfunction onSendToGroup(gameMessage) { return true;}

// Return true if the player is allowed to join the groupfunction onPlayerJoinGroup(groupId, peerId) { return true;}

// Return true if the player is allowed to leave the groupfunction onPlayerLeaveGroup(groupId, peerId) { return true;}

// A simple tick loop example// Checks to see if a minimum amount of time has passed before seeing if the game has endedasync function tickLoop() { const elapsedTime = getTimeInS() - startTime; logger.info("Tick... " + elapsedTime + " activePlayers: " + activePlayers);

// In Tick loop - see if all players have left early after a minimum period of time has passed // Call processEnding() to terminate the process and quit if ( (activePlayers == 0) && (elapsedTime > minimumElapsedTime)) { logger.info("All players disconnected. Ending game"); const outcome = await session.processEnding(); logger.info("Completed process ending with: " + outcome); process.exit(0);

Version76

Amazon GameLift Manuel du développeurAjout en cours de mise en relation FlexMatch

} else { setTimeout(tickLoop, tickTime); }}

// Calculates the current time in secondsfunction getTimeInS() { return Math.round(new Date().getTime()/1000);}

exports.ssExports = { configuration: configuration, init: init, onProcessStarted: onProcessStarted, onMessage: onMessage, onPlayerConnect: onPlayerConnect, onPlayerAccepted: onPlayerAccepted, onPlayerDisconnect: onPlayerDisconnect, onSendToPlayer: onSendToPlayer, onSendToGroup: onSendToGroup, onPlayerJoinGroup: onPlayerJoinGroup, onPlayerLeaveGroup: onPlayerLeaveGroup, onStartGameSession: onStartGameSession, onProcessTerminate: onProcessTerminate, onHealthCheck: onHealthCheck};

Ajout en cours de mise en relation FlexMatchUtilisez GameLift FlexMatch pour ajouter des fonctionnalités de mise en relation des joueurs à vos jeux.FlexMatch est disponible avec les solutions GameLift gérées pour les serveurs de jeux personnalisés etServeurs en temps réel.

FlexMatch associe le service de mise en relation avec un moteur de règles personnalisables. Vouspouvez ainsi concevoir la façon de mettre en relation des joueurs en fonction d'attributs et de modes dejeu adaptés à votre jeu, et vous appuyer sur FlexMatch pour gérer les détails pratiques de la formationde groupes de joueurs et de leur placement dans des jeux. Voir plus de détails sur la mise en relationpersonnalisée dans Exemples FlexMatch d'ensembles de règles (p. 169).

FlexMatch s'appuie sur la fonction des files d'attente. Une fois qu'une mise en relation est créée, FlexMatchen communique les détails à la file d'attente de votre choix. La file d'attente recherche alors les ressourcesd'hébergement disponibles sur vos flottes Amazon GameLift et débute une nouvelle session de jeu.

Les rubriques de cette section illustrent comment ajouter la prise en charge de la mise en relation àdes serveurs et clients de jeux. Pour créer un matchmaker pour votre jeu, consultez Configuration dematchmakers Amazon GameLift FlexMatch (p. 154). Pour plus d'informations sur la manière dontFlexMatch fonctionne, consultez Fonctionnement d'Amazon GameLift FlexMatch (p. 15).

Rubriques• feuille FlexMatch de route de l'intégration d' (p. 78)• Ajouter FlexMatch à un client de jeu (p. 79)• Ajouter FlexMatch à un serveur de jeux (p. 83)• Renvoi de jeux existants avecFlexMatch (p. 85)

Version77

Amazon GameLift Manuel du développeurfeuille FlexMatch de route de l'intégration d'

feuille FlexMatch de route de l'intégration d'FlexMatch est disponible avec les solutions GameLift gérées pour les serveurs de jeux personnalisés et lesServeurs en temps réel. Pour ajouter la mise en relation FlexMatch à votre jeu, veuillez exécuter les tâchessuivantes.

• Définir un matchmaker. Un matchmaker reçoit les demandes de mise en relation des joueurs et lestraite. Il regroupe les joueurs en fonction d'un ensemble de règles définies et, pour chaque mise enrelation réussie, crée une nouvelle session de jeu et de joueur. Suivez ces étapes pour configurer unmatchmaker :• Créer un ensemble de règles. Un ensemble de règles indique au matchmaker comment construire une

mise en relation valide. Il spécifie la structure de l'équipe, ainsi que la manière d'évaluer les joueursafin de les inclure dans une mise en relation. Consultez ces rubriques :• Créer un ensemble FlexMatch de règles (p. 158)• Exemples FlexMatch d'ensembles de règles (p. 169)

• Créer une file d'attente de session de jeu. Une file d'attente localise la région la mieux adaptée àchaque mise en relation et crée une nouvelle session de jeu dans cette région. Vous pouvez utiliserune file d'attente existante ou en créer une nouvelle pour la mise en relation. Consultez cette rubrique :• Création d'une file d'attente (p. 149)

• Configurer des notifications (facultatif). Les demandes de mise en relation étant asynchrones, vousdevez disposer d'un moyen pour suivre le statut des demandes. Les notifications représentent lameilleure option. Consultez cette rubrique :• Configuration de la notification FlexMatch d'événement (p. 186)

• Configurer un matchmaker. Une fois que vous disposez d'un ensemble de règles, d'une file d'attenteet d'une cible pour les notifications, créez la configuration pour votre matchmaker. Consultez cesrubriques :• Concevoir un FlexMatch matchmaker (p. 154)• Créer une configuration de mise en relation (p. 156)

• Intégrez FlexMatch à votre service de client de jeu. Ajoutez des fonctionnalités au service du client de jeupour démarrer de nouvelles sessions de jeu avec la mise en relation. Les demandes de mise en relationspécifient le matchmaker à utiliser et fournissent des données de joueur nécessaires pour la mise enrelation. Consultez cette rubrique :• Ajouter FlexMatch à un client de jeu (p. 79)

• Intégrez FlexMatch à votre serveur de jeux. Ajoutez des fonctionnalités à votre serveur de jeux pourdémarrer des sessions créées par le biais de la mise en relation. Les demandes de ce type de sessionde jeu incluent des informations spécifiques à la partie, y compris les joueurs et les affectations d’équipe.Le serveur de jeux a besoin de pouvoir utiliser ces informations et y accéder lors de la construction d'unesession de jeu pour la mise en relation. Consultez cette rubrique :• Ajouter FlexMatch à un serveur de jeux (p. 83)

• Configurez le remplissage (facultatif).FlexMatch Demandez des mises en relation supplémentairesde joueurs afin de remplir les emplacements ouverts dans les jeux existants. Vous pouvez activer leremplissage automatique pour laisserGameLift gérer les demandes de remplissage. Vous pouvezégalement gérer manuellement le remplissage en ajoutant des fonctionnalités à votre client ou serveurde jeu afin de pouvoir initier des demandes de remplissage. Consultez cette rubrique :• Renvoi de jeux existants avecFlexMatch (p. 85)

Note

Le remplissage FlexMatch n'est pas disponible actuellement pour les jeux qui utilisent Serveursen temps réel.

Version78

Amazon GameLift Manuel du développeurAjouter FlexMatch à un client de jeu

Ajouter FlexMatch à un client de jeuCette rubrique explique comment ajouter la prise en charge de la mise en relation FlexMatch à vosclients de jeu. FlexMatch est disponible avec les solutions GameLift gérées pour les serveurs de jeuxpersonnalisés et les Serveurs en temps réel.

Pour en savoir plus sur FlexMatch et sur la marche à suivre pour configurer un matchmaker personnalisépour vos jeux, consultez les rubriques suivantes :

• feuille FlexMatch de route de l'intégration d' (p. 78)• Fonctionnement d'Amazon GameLift FlexMatch (p. 15)• Configuration de matchmakers Amazon GameLift FlexMatch (p. 154)• Exemples FlexMatch d'ensembles de règles (p. 169)

Pour activer FlexMatch sur vos clients de jeu, vous devez préparer le projet de votre client de jeu, puisajouter les fonctionnalités suivantes :

• Demander la mise en relation pour un ou plusieurs joueurs.• Suivre le statut des demandes de mise en relation.• Demander l'acceptation du joueur pour une mise en relation proposée.• Une fois la session de jeu créée pour la nouvelle rencontre, obtenez les informations de connexion du

joueur et rejoignez le jeu.

Préparation d'un service client pour la mise en relationIl est préférable que votre client de jeu effectue les demandes de mise en relation via un service de jeuxcôté client plutôt que directement. En utilisant une source de confiance, vous pouvez plus facilement vousprotéger contre les tentatives de piratage et les données factices des joueurs. Si votre jeu utilise un serviced’annuaire des sessions, il s'agit d'une bonne option pour traiter les demandes de mise en relation.

Pour préparer le service client, effectuez les tâches suivantes :

• Ajoutez l'GameLiftAPI. Le service du client utilise la fonctionnalité de l'API GameLift, qui fait partie du kitSDK AWS. Consultez la section Pour les services à la clientèle (p. 28) pour en savoir plus sur le kit SDKAWS et pour télécharger la dernière version. Ajoutez ce kit SDK au projet de service de votre client dejeu.

• Configurez un système de tickets de mise en relation. Toutes les demandes de mise en relation doiventavoir un ID de ticket unique. Vous avez besoin d'un mécanisme pour générer des informations uniquesIDs et les affecter à de nouvelles demandes de mise en relation. Un ID de ticket peut utiliser utilisern'importe quel format de chaîne, jusqu'à un maximum de 128 caractères.

• Procurez-vous les informations relatives au matchmaker. Obtenez le nom de la configuration de miseen relation que vous prévoyez d’utiliser. Vous avez également besoin de la liste des attributs de joueurrequis du matchmaker, qui sont définis dans l'ensemble de règles du matchmaker.

• Obtenir les données des joueurs. Configurez un moyen d'obtenir les données pertinentes pour chaquejoueur. Cela inclut l'ID de joueur, les valeurs d'attribut de joueur et les données de latence mises à jourpour chaque région où le joueur est susceptible d'être impliqué dans un jeu.

• Activez le remplissage des parties (facultatif). Déterminez la façon dont vous souhaitez remplir les jeuxexistants. Si le remplissage manuel est configuré pour vos matchmakers, il peut être utile d’ajouter àvotre jeu la prise en charge du remplissage. Si le mode de remplissage est automatique, il se peut quevous deviez inclure un moyen de le désactiver pour les sessions de jeu individuelles. Pour en savoir plussur la gestion du remplissage des parties, voire Renvoi de jeux existants avecFlexMatch (p. 85).

Version79

Amazon GameLift Manuel du développeurAjouter FlexMatch à un client de jeu

Demander la mise en relation des joueursAjoutez du code à votre service client pour créer et gérer les demandes de mise en relation à unmatchmaker FlexMatch.

Création d'une demande de mise en relation :

• Appelez l'GameLiftAPI StartMatchmaking . Chaque demande doit contenir les informations suivantes.

Matchmaker

Nom de la configuration de mise en relation à utiliser pour la demande. FlexMatch place chaquedemande dans le pool du matchmaker spécifié. La demande est traitée en fonction de laconfiguration du matchmaker. Il s'agit notamment d'appliquer une limite de temps, que ce soit pourdemander l'acceptation du joueur pour une partie, la file d'attente à utiliser lorsque vous placezune session de jeu qui en résulte, etc. Pour en savoir plus sur les matchmakers et les ensemblesde règles, voir Concevoir un FlexMatch matchmaker (p. 154).

ID ticket

ID de ticket unique attribué à la demande. Tout élément lié à la demande, y compris lesévénements et les notifications, utilise l’ID de ticket comme référence.

Données du joueur

Liste des joueurs pour lesquels vous voulez créer une mise en relation. Si un des joueurs de lademande ne répond pas aux exigences de mise en relation (selon les règles de mise en relationet les minimums de latence), la demande de mise en relation n'aboutit jamais. Vous pouvezinclure jusqu'à dix joueurs dans une demande de mise en relation. Lorsqu'une demande contientplusieurs joueurs, FlexMatch tente de créer une mise en relation unique et d'affecter tous lesjoueurs à la même équipe (sélectionnée de façon aléatoire). Si une demande contient trop dejoueurs pour constituer une équipe de mise en relation, la demande échoue. Par exemple, si vousavez configuré votre matchmaker pour créer des rencontres 2 contre 2 (deux équipes de deuxjoueurs), vous ne pouvez pas envoyer de demande de mise en relation contenant plus de deuxjoueurs.

Note

Un joueur (identifié par son ID de joueur) ne peut être inclus que dans une seuledemande de mise en relation à la fois. Si vous créez une autre demande pour unjoueur, tous les tickets de mise en relation actifs ayant le même ID de joueur sontautomatiquement annulés.

Pour chaque joueur répertorié, incluez les données suivantes :• ID de joueur – Chaque joueur doit avoir un ID de joueur unique, que vous générez. Veuillez

consulter Génération d'ID de joueur (p. 57).• Attributs de joueur – Si le matchmaker utilisé exige des attributs de joueur, la demande doit

fournir ces attributs pour chaque joueur. Les attributs de joueur nécessaires sont définis dansl'ensemble de règles du matchmaker, qui spécifie également le type de données des attributs.Un attribut de joueur est facultatif uniquement lorsque l'ensemble de règles spécifie une valeurpar défaut pour cet attribut. Si la demande de mise en relation ne fournit pas les attributsde joueur nécessaires pour tous les joueurs, elle n’aboutit pas. Pour en savoir plus sur lesensembles de règles du matchmaker et les attributs de joueur, consultez Créer un ensembleFlexMatch de règles (p. 158) et Exemples FlexMatch d'ensembles de règles (p. 169).

• Latence des joueurs – Si le matchmaker utilisé possède une règle de latence pour les joueurs,la demande doit indiquer la latence pour chaque joueur. Les données de latence des joueurscorrespondent à une liste d'une ou de plusieurs valeurs par joueur. Elles représente la latenceque subit le joueur pour chaque région dans la file d'attente du matchmaker. Si aucune valeur

Version80

Amazon GameLift Manuel du développeurAjouter FlexMatch à un client de jeu

de latence des joueurs n’est incluse dans la demande, le joueur ne peut pas être mis enrelation, et la demande échoue.

Récupération des informations relatives à la demande de mise en relation :

• Une fois qu'une demande de mise en relation est envoyée, vous pouvez afficher les détails de lademande en appelant DescribeMatchmaking avec l'ID de ticket correspondant. Cet appel renvoie lesinformations relatives à la demande, y compris le statut actuel. Une fois qu'une demande se termineavec succès, le ticket contient également les informations nécessaires à la connexion d'un joueur à lapartie.

Annulation d’une demande de mise en relation :

• Vous pouvez annuler une demande de mise en relation à tout moment en appelant StopMatchmaking avec l'ID de ticket de la demande.

Suivre l'état d'une demande de mise en relationAjoutez le code au service de jeu pour suivre le statut de toutes les demandes de mise en relation. Il existedeux approches pour le suivi de l'état : les notifications d'événements et l'interrogation continue.

Vous devez configurer votre jeu avec des notifications d'événements avant d'avoir un volume élevéd'utilisation de la mise en relation, par exemple avec les tests de charge de pré-production. Tous les jeuxen version publique doivent utiliser des notifications quel que soit le volume. L'approche de sondagecontinu n'est appropriée que pour les jeux en développement avec une faible utilisation de la mise enrelation.

Notifications d'événements

Configurez les notifications pour suivre les événements émis par GameLift pour les processus de miseen relation. Vous pouvez configurer les notifications directement, en créant une rubrique SNS, ou enutilisant Amazon EventBridge. Pour plus d'informations sur la configuration des notifications, consultezConfiguration de la notification FlexMatch d'événement (p. 186). Une fois que vous avez configuréles notifications, vous devez ajouter un écouteur au niveau de votre service client pour détecter lesévénements et y répondre si nécessaire.

C'est également une bonne idée de sauvegarder les notifications en interrogeant périodiquement lesmises à jour de statut lorsqu'une période importante passe sans notification. Pour minimiser l'impact surles performances de mise en relation, assurez-vous d'interroger seulement après avoir attendu au moins30 secondes après l'envoi du ticket de mise en relation ou après la dernière notification reçue.

Interrogation continue

Récupérez un ticket de demande de mise en relation, y compris l'état actuel, en appelant DescribeMatchmaking avec l'ID de ticket de la demande. Nous recommandons une interrogation toutes les10 secondes au plus. Cette approche est destinée uniquement aux scénarios de développement à faiblevolume.

Demander l'acceptation du joueurSi vous utilisez un matchmaker pour lequel l'acceptation des joueurs est activée, ajoutez le code à votreservice client pour gérer ce processus d'acceptation.

Demande d'acceptation du joueur pour une mise en relation proposée :

1. Identifier quand une partie proposée nécessite l'acceptation du joueur. Surveillez le ticket demise en relation pour détecter le moment où l'état passe à REQUIRES_ACCEPTANCE . Si vous

Version81

Amazon GameLift Manuel du développeurAjouter FlexMatch à un client de jeu

surveillez les notifications, une modification de ce statut déclenche l'FlexMatchévénementMatchmakingRequiresAcceptance .

2. Obtenir les acceptations de tous les joueurs. Créez un mécanisme pour présenter les détails de lapartie proposée à chaque joueur associé au ticket de mise en relation. Les joueurs doivent être enmesure d'indiquer qu'ils acceptent ou refusent la partie proposée. Vous pouvez récupérer les détails dela mise en relation en appelant DescribeMatchmaking . Les joueurs ont un temps limité pour répondreavant que le matchmaker supprime la mise en relation proposée et passe à l'étape suivante.

3. Signaler les réponses des joueurs à FlexMatch . Signalez les réponses des joueurs en appelant AcceptMatch avec acceptation ou rejet. Tous les joueurs d'une demande doivent accepter la mise enrelation pour que celle-ci se poursuive.

4. Gérer les tickets avec les acceptations ayant échoué. Une demande échoue lorsqu'un joueur refuse lapartie proposée ou ne parvient pas à répondre dans les limites imparties.

Se connecter à une mise en relationAjoutez du code à votre service de jeu pour gérer une mise en relation ayant réussi (état COMPLETED ouévénement MatchmakingSucceeded). Ce processus inclut la notification des joueurs concernés et l’envoides informations de connexion à leurs clients de jeu.

Lorsqu'une demande de mise en relation est terminée, les informations de connexion sont ajoutéesau ticket de mise en relation. Pour récupérer un ticket de mise en relation terminée en appelant DescribeMatchmaking . Les informations de connexion incluent l'adresse IP et le port de la sessionde jeu, ainsi qu'un ID de session de joueur pour chaque ID de joueur. Pour en savoir plus, voirGameSessionConnectionInfo.

Votre client de jeu utilise ces informations pour vous connecter directement à la session de jeu qui hébergela partie. Une demande de connexion pour une session de jeu correspondante doit inclure un ID de sessionde joueur et un ID de joueur. Ces données associent le joueur connecté aux données de mise en relationde la session de jeu, ce qui inclut les affectations de l'équipe (voir GameSession ).

Exemples de demandes de mise en relationLes extraits de code suivants construisent les demandes de mise en relation pour différents matchmakers.Comme décrit, une demande doit fournir les attributs de joueur qui sont requis par le matchmaker utilisé, telque défini dans l'ensemble de règles de ce dernier. L'attribut fourni doit utiliser le même type de données, lemême numéro (N) ou la même chaîne (S) que dans l'ensemble de règles.

# 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): 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": {

Version82

Amazon GameLift Manuel du développeurAjouter FlexMatch à un serveur de jeux

"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)

Ajouter FlexMatch à un serveur de jeuxCette rubrique explique comment ajouter la prise en charge de la mise en relation FlexMatch à votreserveur de jeux. FlexMatch est disponible avec les solutions GameLift gérées pour les serveurs de jeuxpersonnalisés et les Serveurs en temps réel. Pour en savoir plus sur l'ajout de FlexMatch à vos jeux,consultez les rubriques suivantes :

• Fonctionnement d'Amazon GameLift FlexMatch (p. 15)• feuille FlexMatch de route de l'intégration d' (p. 78)

Les informations de cette rubrique supposent que vous avez intégré le kit SDK GameLift Server à votreprojet de serveur de jeux, comme décrit dans Ajouter GameLift vers votre serveur de jeux (p. 46).Une fois cette tâche terminée, vous disposez de la plupart des mécanismes dont vous avez besoin. Lessections de cette rubrique couvrent les tâches restantes nécessaires au traitement des jeux configurésavec FlexMatch.

Configuration de votre serveur de jeux pour la mise en relationPour configurer votre serveur de jeu au traitement des jeux correspondants, réalisez les étapes suivantes.

1. Lancer des sessions de jeu créées avec la mise en relation. Pour demander une nouvelle sessionde jeu, GameLift envoie une onStartGameSession() demande à votre serveur de jeux avec unobjet de session de jeu (consultez GameSession ). Pour démarrer la session de jeu demandée,

Version83

Amazon GameLift Manuel du développeurAjouter FlexMatch à un serveur de jeux

votre serveur de jeu utilise les informations de session de jeu, notamment les données de jeupersonnalisées. Pour en savoir plus, consultez Démarrer une session de jeu (p. 48).

Pour les jeux mis en relation, l'objet de session de jeu contient également un ensemble de donnéesdu matchmaker. Ces dernières comprennent les informations nécessaires à votre serveur de jeuxafin de configurer une nouvelle session de jeu pour la partie. Cela inclut la structure de l'équipe,les affectations d'équipe et certains attributs de joueur qui peuvent être utiles pour votre jeu. Parexemple, votre jeu peut débloquer certaines fonctionnalités ou certains niveaux en fonction du niveaude compétence des joueurs, ou peut choisir une carte en fonction des préférences des joueurs. Pouren savoir plus, voir Utiliser des données de matchmaker (p. 84).

2. Gérer les connexions des joueurs. Lors de la connexion à un jeu, le client de jeu se réfère à un IDde joueur et à un ID de session de joueur (voirValider un nouveau joueur (p. 48)). Le serveur dejeux utilise l'ID de joueur pour associer le joueur entrant aux informations contenues dans les donnéesdu matchmaker. Les données du matchmaker identifient l'affectation d'équipe de chaque joueur etpeuvent fournir d'autres informations nécessaires à la bonne représentation du joueur dans le jeu.

3. Signaler que des joueurs quittent le jeu. Veillez à ce que votre serveur de jeux appelle l'API de serveurRemovePlayerSession() pour signaler la perte de joueurs (consultez Signaler la fin d’une sessionde joueur (p. 48)). Cette étape est importante si vous utilisez le remplissage FlexMatch pour remplirles emplacements vides dans des jeux existants. Elle est essentielle si votre jeu initie les demandesde remplissage via un service de jeu côté client. Pour plus d'informations sur l'implémentation duremplissage FlexMatch, consultez Renvoi de jeux existants avecFlexMatch (p. 85).

4. Demander de nouveaux joueurs pour des sessions de jeu correspondant existantes (facultatif).Déterminez la façon dont vous souhaitez remplir les jeux existants. Si le remplissage manuelest configuré pour vos matchmakers, il peut être utile d’ajouter à votre jeu la prise en charge duremplissage. Si le mode de remplissage est automatique, il se peut que vous deviez inclure un moyende le désactiver pour les sessions de jeu individuelles. Par exemple, vous pouvez choisir d’arrêter leremplissage d'une session une fois qu'un certain stade est atteint dans le jeu. Pour en savoir plus surla gestion du remplissage des parties, voire Renvoi de jeux existants avecFlexMatch (p. 85).

Utiliser des données de matchmakerVotre serveur de jeux doit être en mesure de reconnaître et d'utiliser les informations de jeu dans un GameSession objet. Le service GameLift transmet ces objets à votre serveur de jeux chaque fois qu'unesession de jeu est lancée ou mise à jour. Les informations de session de jeu principales comprennentl'ID et le nom de la session de jeu, le nombre maximum de joueurs, les informations de connexion et lesdonnées de jeu personnalisées (si fournies).

Pour les sessions de jeu qui sont créées à l'aide de FlexMatch, l'objet GameSession contient égalementun ensemble de données du matchmaker. En plus d'un ID de partie unique, il identifie le matchmaker utilisépour créer la rencontre et décrit les équipes, les affectations de l'équipe et les joueurs. Il comprend lesattributs de joueur depuis la demande de mise en relation d'origine (consultez l'objet Player (joueur)). Il necomprend pas la latence du joueur. Si vous avez besoin des données de latence des joueurs actuels, parexemple dans le cadre d'un remplissage de rencontre, nous vous recommandons d'actualiser les données.

Note

Les données du matchmaker spécifient l'ARN de configuration de correspondance complet, quiidentifie le nom de la configuration, le compte AWS et la région. Lorsque vous demandez unremplissage de partie depuis un client ou un service de jeux, seul le nom de la configurationest nécessaire. Vous pouvez extraire le nom de la configuration en analysant la chaîne quisuit « :matchmakingconfiguration/ ». Dans l'exemple indiqué, le nom de la configuration decorrespondance est « MyMatchmakerConfig ».

Le code JSON suivant illustre un ensemble de données de matchmaker typique. Cet exemple décrit un jeuà deux joueurs, les joueurs étant mis en relation en fonction de leurs scores de compétence et du niveauatteint le plus élevé. Le matchmaker base également la mise en relation sur le personnage et garantie que

Version84

Amazon GameLift Manuel du développeurRenvoi des jeux existants

les joueurs mis en relation ont au moins une préférence de carte en commun. Dans ce scénario, le serveurde jeux doit être en mesure de déterminer quelle carte est la préférée et de l'utiliser dans la session de jeu.

{ "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}} } }] }]}

Renvoi de jeux existants avecFlexMatchLe remplissage utilise vos mécanismes FlexMatch pour trouver de nouveaux joueurs pour de sessionsde jeu mises en correspondance existantes. Même si vous avez toujours la possibilité d'ajouter desjoueurs à n'importe quel jeu (consultez Ajout d'un joueur à une session de jeu (p. 56)), le renvoi decorrespondance garantit que les nouveaux joueurs répondent aux mêmes critères de correspondanceque les joueurs actuels. En outre, le remplissage des parties attribue les nouveaux joueurs à des équipes,gère l'acceptation des joueurs et envoie des informations mises à jour sur les parties au serveur de jeux.Découvrez le renvoi de correspondance dans Processus de mise en relation (p. 16).

Note

Le remplissage FlexMatch n'est pas disponible actuellement pour les jeux qui utilisent Serveurs entemps réel.

Il existe deux types de mécanismes de remplissage :

• Pour remplir les sessions de jeu qui commencent avec un nombre de joueurs inférieur au nombremaximum autorisé, activez le remplissage automatique.

• Pour remplacer les joueurs qui abandonnent une session de jeu en cours, ajoutez des fonctionnalités àvotre serveur de jeu afin d'envoyer des demandes de remplissage.

Activation du remplissage automatiqueAvec le remplissage automatique, GameLift déclenche automatiquement une demande de remplissagechaque fois qu'une session de jeu commence avec un ou plusieurs emplacements de joueur nonremplis. Cette fonction permet de commencer les parties dès que le nombre minimum de joueurs misen correspondance est trouvé et de remplir les emplacements restants plus tard, lorsque des joueurssupplémentaires sont mis en correspondance. Vous pouvez choisir d'arrêter le remplissage automatique àtout moment.

Version85

Amazon GameLift Manuel du développeurRenvoi des jeux existants

A titre d'exemple, imaginons un jeu pouvant contenir de six à dix joueurs. localise FlexMatch initialementsix joueurs, forme la mise en relation et démarre une nouvelle session de jeu. Avec le remplissageautomatique, la nouvelle session de jeu peut immédiatement demander quatre joueurs supplémentaires.En fonction du style de jeu, nous pouvons autoriser de nouveaux joueurs à rejoindre la session de jeuà tout moment. Nous pouvons également vouloir arrêter le remplissage automatique après la phase deconfiguration initiale et avant le début du jeu.

Pour ajouter le remplissage automatique à un jeu, effectuez les mises à jour suivantes.

1. Activez le remplissage automatique. Le remplissage automatique est géré dans la configuration de lamise en relation. Lorsque cette option est activée, elle est utilisée avec toutes les sessions de jeu quisont créées avec ce matchmaker. GameLift commence la génération des demandes de remplissagepour les sessions de jeu non remplies dès qu’elles démarrent sur un serveur de jeux.

Pour activer le remplissage automatique, ouvrez la configuration d’une mise en relation et définissezle mode de remplissage sur « AUTOMATIQUE ». Pour plus d'informations, consultez Créer uneconfiguration de mise en relation (p. 156).

2. Permet d'activer la hiérarchisation du remplissage. Personnalisez votre processus de mise en relationpour hiérarchiser le remplissage des requêtes de remplissage avant de créer de nouvelles rencontres.Dans votre ensemble de règles de mise en relation, ajoutez un composant d'algorithme et définissezla priorité de remplissage sur « élevé ». Pour en savoir plus, consultez Personnalisation de l'algorithmede correspondance (p. 159).

3. Remplacez les données de session de jeu par les nouvelles données du matchmaker. AmazonGameLift mettra à jour le serveur de jeux avec les informations correspondantes à l'aide de la fonctionde rappel du kit SDK Server onUpdateGameSession (voir Initialiser le processus serveur (p. 46)).Ajoutez du code au serveur de jeux pour traiter les mises à jour des objets de session de jeu suite àl'action de remplissage. Pour en savoir plus, voir Mise à jour des données de mise en relation sur leserveur de jeux (p. 91).

4. Désactivez le remplissage automatique pour une session de jeu. Vous pouvez choisir d'arrêter leremplissage automatique à tout moment au cours d'une session de jeu individuelle. Pour arrêter leremplissage automatique, ajoutez du code à votre client ou serveur de jeux pour effectuer l'appelGameLift d'API StopMatchmaking . Cet appel nécessite un ID ticket. Utilisez l'ID de ticket de ladernière demande de remplissage. Vous pouvez obtenir ces informations à partir des données de miseen relation de la session de jeu, lesquelles sont mises à jour comme décrit à l'étape précédente.

Envoi de demandes de remplissage (à partir d'un serveur de jeux)Vous pouvez initier des requêtes de renvoi de correspondance directement depuis le processus de serveurde jeu qui héberge la session de jeu. Le processus serveur dispose des informations les plus récentes surles joueurs actuels connectés au jeu et le statut des emplacements de joueur vides.

Il suppose que vous avez déjà créé les composants FlexMatch nécessaires et ajouté avec succès lesprocessus de mise en relation au serveur de jeux et à un service de jeu côté client. Pour plus d'informationssur la configuration de FlexMatch, consultez feuille FlexMatch de route de l'intégration d' (p. 78).

Pour activer le remplissage des parties pour votre jeu, vous devez ajouter les fonctionnalités suivantes :

• Envoyer les demandes de remplissage à un matchmaker et suivre l'état de ces demandes.• Mettre à jour les informations de correspondance pour la session de jeu. Veuillez consulter Mise à jour

des données de mise en relation sur le serveur de jeux (p. 91).

Comme pour les autres fonctionnalités de serveur, un serveur de jeux utilise le kit SDK Amazon GameLiftServer. Ce kit SDK est disponible en C++ et C#. Pour une description générale de APIs Server , consultezles références d'API Server (p. 264) .

Version86

Amazon GameLift Manuel du développeurRenvoi des jeux existants

Pour créer des requêtes de renvoi de correspondance depuis votre serveur de jeux, exécutez les tâchessuivantes.

1. Déclenchez une requête de renvoi de correspondance. En général, vous pouvez si vous le souhaitezinitier une requête de renvoi chaque fois qu'un jeu correspondant comporte un ou plusieursemplacements de joueur vides. Vous pouvez si vous le souhaitez lier des requêtes de renvoi à descirconstances spécifiques, comme des rôles de personnages critiques ou l'équilibrage des équipes.Vous pouvez aussi limiter l'activité de renvoi en fonction de l'ancienneté d'une session de jeu.

2. Créez une requête de renvoi. Ajoutez le code pour créer et envoyer les requêtes de renvoi decorrespondance à un matchmaker FlexMatch. Les requêtes de renvoi sont gérées à l'aide de ceserveur APIs :

• StartMatchBackfill (p. 294)• StopMatchBackfill() (p. 295)

Pour créer une requête de renvoi, appelez StartMatchBackfill avec les informations suivantes.Pour annuler une requête de renvoi, appelez StopMatchBackfill avec l'identifiant de ticket derequête de renvoi.

• Ticket ID (ID de ticket) — Fournissez un identifiant de ticket de mise en relation (ou choisissez qu'ilsoit généré automatiquement). Vous pouvez utiliser le même mécanisme pour attribuer un ticket auxrequêtes de correspondance et de renvoi.IDs Les tickets de correspondance et de renvoi sont traitésde la même manière.

• Matchmaker — Identifiez le matchmaker à utiliser pour la requête de renvoi. En général, vousdevrez utiliser le matchmaker qui a été utilisé pour créer la correspondance d'origine. Cette requêtenécessite un ARN de configuration de correspondance. Ces informations sont stockées dans l'objetde session de jeu (GameSession), qui a été fourni au processus serveur par Amazon GameLift lorsde l'activation de la session de jeu. L'ARN de configuration de correspondance est inclus dans lapropriété MatchmakerData.

• Game session ARN (ARN de session de jeu) — Identifiez la session de jeu en coursde renvoi. Vous pouvez obtenir l'ARN de session de jeu en appelant l'API de serveurGetGameSessionId() (p. 288). Pendant le processus de correspondance, les tickets des nouvellesrequêtes n'ont pas d'identifiant de session de jeu, tandis que les tickets des requêtes de renvoi enont un. La présence d'un identifiant de session de jeu est un moyen de faire la différence entre lestickets des nouvelles correspondances et les tickets des renvois.

• Données du joueur — Incluez les informations de joueur (Joueur) de tous les joueurs en cours dansla session de jeu que vous êtes en train de renvoyer. Ces information permettent au matchmaker delocaliser les meilleures correspondances de joueur possibles pour les joueurs actuellement dans lasession de jeu. Si votre serveur de jeux indique de manière précise l'état de connexion des joueurs,vous devez pouvoir acquérir ces données comme suit :1. Le processus de serveur qui héberge la session de jeu doit avoir les informations les plus

récentes concernant les joueurs actuellement connecté à la session de jeu.2. Pour obtenir IDs les attributs de joueur et les affectations d'équipe, extrayez les données de

joueur de l'objet de session de jeu (GameSession), MatchmakerData la propriété (consultezUtiliser des données de matchmaker (p. 84) . Les données du matchmaker incluent tous lesjoueurs qui ont été mis en correspondance avec la session de jeu, vous devez donc extraire lesdonnées de joueur des joueurs actuellement connectés uniquement.

3. Pour la latence de joueur, si le matchmaker appelle les données de latence, collectez lesnouvelles valeurs de latence de tous les joueurs actuels et incluez-les dans chaque objetPlayer. Si les données de latence sont omises et si le matchmaker utilise une règle de latence,la requête ne sera pas correctement mise en correspondance. Les requêtes de renvoi nécessitentles données de latence uniquement pour la région dans laquelle se trouve actuellement la sessionde jeu. Vous pouvez obtenir la région d'une session de jeu dans la propriété GameSessionId del'objet GameSession ; cette valeur est un ARN, lequel inclut la région.

Version87

Amazon GameLift Manuel du développeurRenvoi des jeux existants

3. Suivez le statut d'une requête de renvoi. Amazon GameLift informe votre serveur de jeux de l'étatde requêtes de renvoi à l'aide de la fonction de rappel du kit SDK Server onUpdateGameSession(consultez Initialiser le processus serveur (p. 46)). Ajoutez le code permettant de traiter lesmessages d'état, ainsi que les objets de session de jeu mis à jour suite aux requêtes de renvoitraitées, à l'adresse Mise à jour des données de mise en relation sur le serveur de jeux (p. 91). ——

Un matchmaker peut uniquement traiter une seul requête de renvoi de correspondance depuis unesession de jeu à la fois. Si vous devez annuler une requête, appelez StopMatchBackfill() (p. 295).Si vous devez modifier une requête, appelez StopMatchBackfill et soumettez une requête mise àjour.

Envoi de requêtes de renvoi (depuis un service client)Comme alternative à l'envoi de requêtes de renvoi à partir d'un serveur de jeux, vous pouvez les envoyerà partir d'un service de jeu côté client. Pour utiliser cette option, le service côté client doit avoir accès auxdonnées actuelles sur l'activité de session de jeu et des connexions joueur. Si votre jeu utilise un serviced'annuaire de session, cela pourrait être un bon choix.

Il suppose que vous avez déjà créé les composants FlexMatch nécessaires et ajouté avec succès lesprocessus de mise en relation au serveur de jeux et à un service de jeu côté client. Pour plus d'informationssur la configuration de FlexMatch, consultez feuille FlexMatch de route de l'intégration d' (p. 78).

Pour activer le remplissage des parties pour votre jeu, vous devez ajouter les fonctionnalités suivantes :

• Envoyer les demandes de remplissage à un matchmaker et suivre l'état de ces demandes.• Mettre à jour les informations de correspondance pour la session de jeu. Consultez

Quelle que soit la manière dont vous initiez les requêtes de renvoi dans votre jeu, votreserveur de jeux doit être en mesure de gérer les mises à jour de session de jeu fourniespar Amazon GameLift suite au résultats de requêtes de renvoi de correspondance.

Lorsque Amazon GameLift termine une requête de renvoi — de correspondance, elleappelle votre serveur de jeux via la fonction de rappel — .onUpdateGameSession Cetappel comporte trois paramètres d'entrée : un ID de ticket de renvoi de correspondance,un message de statut et un GameSession objet contenant les données de correspondanceles plus récentes, y compris les informations sur les joueurs. Vous devez ajouter le codesuivant à votre serveur de jeux dans le cadre de votre intégration au serveur de jeux :

1. Implémentez la fonction onUpdateGameSession. Cette fonction doit pouvoir gérer lesmessages de statut suivants (updateReason) :• MATCHMAKING_DATA_UPDATED – Les nouveaux joueurs ont été mis en

correspondance avec la session de jeu. L'objet GameSession contient les donnéesde matchmaker mises à jour; y compris les données de joueur sur les joueursexistants et les joueurs nouvellement mis en correspondance.

• BACKFILL_FAILED – La tentative de renvoi de correspondance a échoué en raisond'une erreur interne. L'objet GameSession est inchangé.

• BACKFILL_TIMED_OUT – Le matchmaker n'a pas trouvé de correspondance derenvoi dans le délai imparti. L'objet GameSession est inchangé.

• BACKFILL_CANCELLED – : la requête de renvoi de correspondance a été annuléepar un appel à StopMatchmaking (client) ou StopMatchBackfill (serveur). L'objetGameSession est inchangé.

2. Pour que les correspondances de renvoi aboutissent, utilisez les données matchmakermises à jour pour gérer les nouveaux joueurs lorsqu'ils se connectent à la session dejeu. Au minimum, vous devrez utiliser les affectations d'équipe pour le ou les nouveauxjoueurs, ainsi que d'autres attributs de joueur qui sont requis pour que le joueur puissedémarrer dans le jeu.

Version88

Amazon GameLift Manuel du développeurRenvoi des jeux existants

3. Dans l'appel du serveur de jeux à l'action SDK Server ProcessReady() (p. 291),ajoutez le nom de la méthode de rappel onUpdateGameSession en tant queparamètre de traitement.

(p. 91).

Comme pour les autres fonctionnalités clientes, un service de jeu côté client utilise AWS SDK avecl'API Amazon GameLift. Ce kit SDK est disponible en C++, C # et plusieurs autres langages. Pour unedescription générale du client APIs , consultez la Référence API Amazon GameLift Service, qui décrit l'APIde service de bas niveau pour les actions liées à Amazon et inclut des liens vers les guides de référencepropres au langage.GameLift

Pour configurer un service de jeu côté client pour le renvoi de jeux correspondants, exécutez les tâchessuivantes.

1. Déclenchez une requête pour le renvoi. En général, un jeu initie une requête de renvoi chaque foisqu'un jeu correspondant comporte un ou plusieurs emplacements de joueur vides. Vous pouvez sivous le souhaitez lier des requêtes de renvoi à des circonstances spécifiques, comme des rôles depersonnages critiques ou l'équilibrage des équipes. Vous pouvez aussi limiter le renvoi en fonctionde l'ancienneté d'une session de jeu. Quel que soit l'élément que vous utilisez pour un déclencheur,vous devrez au minimum connaître les informations suivantes. Vous pouvez obtenir ces informations àpartir de l'objet de session de jeu (GameSession) en appelant DescribeGameSessions avec un ID desession de jeu.

• Nombre d'emplacements de joueur actuellement vides. Cette valeur peut être calculée à partir dela limite de joueur maximale d'une session de jeu et du nombre de joueurs en cours. Le nombre dejoueurs en cours est mis à jour dès que votre serveur de jeux contacte les service Amazon GameLiftpour valider la connexion d'un nouveau joueur ou pour signaler un joueur qui a abandonné.

• Stratégie de création. Ce paramètre indique si la session de jeu accepte actuellement de nouveauxjoueurs.

L'objet de session de jeu peut potentiellement contenir d'autres informations utiles, comme l'heure dedébut de la session de jeu, les propriétés de jeu personnalisées et les données de matchmaker.

2. Créez une requête de renvoi. Ajoutez le code pour créer et envoyer les requêtes de renvoi decorrespondance à un matchmaker FlexMatch. Les requêtes de renvoi sont gérées à l'aide de cesclients APIs :

• StartMatchBackfill• StopMatchmaking

Pour créer une requête de renvoi, appelez StartMatchBackfill avec les informations suivantes.Une requête de renvoi est similaire à une requête de correspondance (consultez Demander la mise enrelation des joueurs (p. 80)), mais elle identifie également la session de jeu existante. Pour annulerune requête de renvoi, appelez StopMatchmaking avec l'identifiant de ticket de requête de renvoi.

• Ticket ID (ID de ticket) — Fournissez un identifiant de ticket de mise en relation (ou choisissez qu'ilsoit généré automatiquement). Vous pouvez utiliser le même mécanisme pour attribuer un ticket auxrequêtes de correspondance et de renvoi.IDs Les tickets de correspondance et de renvoi sont traitésde la même manière.

• Matchmaker — Identifiez le nom d'une configuration de mise en relation à utiliser. En général, vousdevrez utiliser le matchmaker pour le renvoi qui a été utilisé pour créer la correspondance d'origine.Ces informations se trouvent dans un objet de session de jeu (GameSession), MatchmakerDatapropriété sous l'ARN de configuration de mise en relation. La valeur de nom est la chaîne qui

Version89

Amazon GameLift Manuel du développeurRenvoi des jeux existants

suit « matchmakingconfiguration / ». (Par exemple, dans la valeur d'ARN « arn:aws:gamelift:us-west-2:111122223333:matchmakingconfiguration/MM-4v4 », le nom de la configuration de mise enrelation est « MM-4v4 ».)

• Game session ARN (ARN de la session de jeu) — Indiquez la session de jeu en cours de renvoi.Utilisez la propriété GameSessionId de l'objet de session de jeu ; cet identifiant utilise la valeurd'ARN dont vous avez besoin. Les tickets de mise en relation (MatchmakingTicket) pour lesrequêtes de renvoi ont l'ID de session de jeu pendant leur traitement ; les tickets pour les nouvellesrequêtes de mise en relation n'obtiennent pas d'ID de session de jeu tant que la rencontre n'est pasplacée ; la présence au niveau de l'ID de session de jeu est un moyen de faire la différence entre lestickets pour les nouvelles rencontres et les tickets pour les renvois.

• Données du joueur — Incluez les informations de joueur (Joueur) de tous les joueurs en cours dansla session de jeu que vous êtes en train de renvoyer. Ces information permettent au matchmaker delocaliser les meilleures correspondances de joueur possibles pour les joueurs actuellement dans lasession de jeu. Si votre serveur de jeux indique de manière précise l'état de connexion des joueurs,vous devez pouvoir acquérir ces données comme suit :1. Appelez DescribePlayerSessions () avec l'ID de session de jeu pour découvrir tous les joueurs

qui sont actuellement connectés à la session de jeu. Chaque session de joueur inclut unidentifiant de joueur. Vous pouvez ajouter un filtre de statut pour récupérer les sessions de joueuractives uniquement.

2. Procédez à l'extraction des données de joueur à partir de l'objet de session de jeu(GameSession), MatchmakerData propriété (consultez Utiliser des données dematchmaker (p. 84) ). Utilisez le joueur IDs acquis à l'étape précédente pour obtenir desdonnées pour les joueurs actuellement connectés uniquement. Dans la mesure où les donnéesde matchmaker ne sont pas mises à jour lorsque les joueurs abandonnent, vous devez extraireles données des joueurs actuels uniquement.

3. Pour la latence de joueur, si le matchmaker appelle les données de latence, collectez lesnouvelles valeurs de latence de tous les joueurs actuels et incluez-les dans l'objet Player. Si lesdonnées de latence sont omises et si le matchmaker utilise une règle de latence, la requête nesera pas correctement mise en correspondance. Les requêtes de renvoi nécessitent les donnéesde latence uniquement pour la région dans laquelle se trouve actuellement la session de jeu.Vous pouvez obtenir la région d'une session de jeu dans la propriété GameSessionId de l'objetGameSession ; cette valeur est un ARN, lequel inclut la région.

3. Suivez l'état de la requête de renvoi. Ajoutez du code pour écouter les mises à jour de statut du ticketde correspondance. Vous pouvez utiliser le mécanisme défini pour suivre les tickets des nouvellesrequêtes de correspondance (consultez Suivre l'état d'une demande de mise en relation (p. 81))à l'aide de la notification d'événement (préférée) ou l'interrogation. Même s'il n'est pas nécessaire dedéclencher l'activité d'acceptation de joueur à l'aide de requêtes de renvoi, et si les informations dejoueur sont mises à jour sur le serveur de jeux, vous devez toujours surveiller le statut du ticket pourgérer les erreurs de requêtes et les nouvelles soumissions de requêtes.

Un matchmaker peut uniquement traiter une seul requête de renvoi de correspondance depuis unesession de jeu à la fois. Si vous avez besoin d'annuler une demande, appelez StopMatchmaking .Si vous avez besoin de modifier une demande, appelez StopMatchmaking , puis soumettez unedemande mise à jour.

Dès qu'une requête de renvoi aboutit, votre serveur de jeux reçoit un objet GameSession mis à jouret gère les tâches nécessaires pour associer de nouveaux joueurs à la session de jeu. Pour plusd'informations, consultez Mise à jour des données de mise en relation sur le serveur de jeux (p. 91).

Version90

Amazon GameLift Manuel du développeurRenvoi des jeux existants

Mise à jour des données de mise en relation sur le serveur dejeuxQuelle que soit la manière dont vous initiez les requêtes de renvoi dans votre jeu, votre serveur de jeuxdoit être en mesure de gérer les mises à jour de session de jeu fournies par Amazon GameLift suite aurésultats de requêtes de renvoi de correspondance.

Lorsque Amazon GameLift termine une requête de renvoi — de correspondance, elle appelle votre serveurde jeux via la fonction de rappel — .onUpdateGameSession Cet appel comporte trois paramètresd'entrée : un ID de ticket de renvoi de correspondance, un message de statut et un GameSession objetcontenant les données de correspondance les plus récentes, y compris les informations sur les joueurs.Vous devez ajouter le code suivant à votre serveur de jeux dans le cadre de votre intégration au serveur dejeux :

1. Implémentez la fonction onUpdateGameSession. Cette fonction doit pouvoir gérer les messages destatut suivants (updateReason) :• MATCHMAKING_DATA_UPDATED – Les nouveaux joueurs ont été mis en correspondance avec la

session de jeu. L'objet GameSession contient les données de matchmaker mises à jour; y compris lesdonnées de joueur sur les joueurs existants et les joueurs nouvellement mis en correspondance.

• BACKFILL_FAILED – La tentative de renvoi de correspondance a échoué en raison d'une erreurinterne. L'objet GameSession est inchangé.

• BACKFILL_TIMED_OUT – Le matchmaker n'a pas trouvé de correspondance de renvoi dans le délaiimparti. L'objet GameSession est inchangé.

• BACKFILL_CANCELLED – : la requête de renvoi de correspondance a été annulée par un appel àStopMatchmaking (client) ou StopMatchBackfill (serveur). L'objet GameSession est inchangé.

2. Pour que les correspondances de renvoi aboutissent, utilisez les données matchmaker mises à jourpour gérer les nouveaux joueurs lorsqu'ils se connectent à la session de jeu. Au minimum, vous devrezutiliser les affectations d'équipe pour le ou les nouveaux joueurs, ainsi que d'autres attributs de joueurqui sont requis pour que le joueur puisse démarrer dans le jeu.

3. Dans l'appel du serveur de jeux à l'action SDK Server ProcessReady() (p. 291), ajoutez le nom de laméthode de rappel onUpdateGameSession en tant que paramètre de traitement.

Version91

Amazon GameLift Manuel du développeurÀ propos des ressources d'hébergement GameLift

Gestion des ressourcesd'hébergement GameLift

Les rubriques de cette section proposent une aide détaillée pour configurer et gérer les ressourcesd'hébergement de vos serveurs de jeux qui seront utilisées avec une solution GameLift gérée. Lorsquevous déployez un serveur de jeux totalement personnalisé ou que vous utilisez Serveurs en temps réel,vous devez allouer des ressources, les configurer et mettre à l'échelle la capacité pour répondre à lademande des joueurs.

Conseil

Informez-vous sur les façons d'explorer les fonctions Amazon GameLift, en particulier Serveurs entemps réel, à l'aide des exemples de jeux. (p. 32).

Rubriques• À propos des ressources d'hébergement Amazon GameLift (p. 92)• Créer des ressources à l'aide de AWS CloudFormation (p. 94)• Chargement de builds et de scripts sur GameLift (p. 101)• Configuration de flottes GameLift (p. 110)• Dimensionnement de la capacité d'une flotte GameLift (p. 133)• Utilisation de files d'attente sur plusieurs régions (p. 143)• Configuration de matchmakers Amazon GameLift FlexMatch (p. 154)• Homologation VPC pour GameLift (p. 187)

À propos des ressources d'hébergement AmazonGameLift

Cette rubrique fournit un bref aperçu des principales ressources que vous utilisez lorsque vous faites appelau service GameLift géré pour héberger vos jeux. En savoir plus sur le fonctionnement d’GameLift dansFonctionnement d'un Amazon GameLift (p. 3).

Le diagramme suivant illustre la structure de base des ressources GameLift et leur relation entre elles.Comme indiqué, vous pouvez structurer un ensemble de ressources pour déployer une ou plusieurs flottesavec une seule build ou un seul script.

Version92

Amazon GameLift Manuel du développeurÀ propos des ressources d'hébergement GameLift

Build

Logiciel de serveur de jeu personnalisé qui est exécuté sur GameLift et qui héberge les sessions dejeu de vos joueurs. Le build d’un jeu représente l'ensemble de fichiers qui permettent l’exécution devotre serveur de jeu sur un système d'exploitation. Vous pouvez avoir plusieurs builds distincts, parexemple pour différentes variantes de votre jeu. La build de jeu doit être intégrée au service GameLift.Vous téléchargez des fichiers de build de jeu sur le service GameLift dans chaque région où vousprévoyez de déployer votre jeu.

Script

La configuration et la logique de jeu personnalisée à utiliser avec Serveurs en temps réel sont fourniespar GameLift à la place d’un serveur de jeux personnalisé. Vous créez un script avec JavaScript pourconfigurer Serveurs en temps réel pour vos clients de jeux et ajouter une logique de jeu personnaliséeselon les besoins afin d'héberger les sessions de jeu de vos joueurs. Vous téléchargez le scriptRealtime sur le service GameLift dans chaque région où vous prévoyez de déployer votre jeu.

Parc

Collection de ressources d'hébergement virtuelles qui exécutent vos serveurs de jeux et hébergent lessessions de jeu de vos joueurs. Vous créez une flotte pour déployer votre build de jeu personnaliséeou un script de serveur Realtime dans une région, et vous configurez la façon dont vous voulez quela flotte fonctionne pour votre jeu. Vous définissez les règles pour gérer la taille de la flotte, ce quidétermine le nombre de sessions de jeux et de joueurs qu’elle peut accueillir. Vous pouvez créerplusieurs flottes pour une build ; par exemple, vous pouvez créer une flotte Spot et une flotte à lademande pour une build. Lorsque vous déployez votre jeu dans plusieurs régions, vous créez uneflotte dans chaque région où vous prévoyez de déployer votre jeu.

Alias

Identifiant abstrait d'une flotte. Vous pouvez modifier la flotte vers laquelle il pointe à tout moment.Étant donné que les flottes sont remplacées chaque fois que vous mettez à jour votre build de jeupersonnalisée, il est recommandé de créer un alias et d’utiliser celui-ci partout où vous avez besoin defaire référence à une flotte spécifique (par exemple, dans une file d'attente de session de jeu). Lorsquevous remplacez la flotte et que celle-ci est prête pour la mise en service, changez d'alias pour pointervers la nouvelle flotte et rediriger vos joueurs sans interruption. Vous créez un alias dans la mêmerégion que la flotte vers laquelle il pointe.

File d'attente de session de jeu

Liste des destinations (flottes ou alias) où les sessions de jeu peuvent être hébergées. Une demandede nouvelle session de jeu doit spécifier où placer la session en fournissant soit un ID de flottespécifique, soit un ID de file d'attente de session de jeu. Les files d'attente, qui peuvent pointer versdes destinations dans plusieurs régions, permettent un placement plus rapide et plus efficace dessessions de jeu. Vous pouvez définir votre file d'attente pour appliquer les limites de latence desjoueurs afin de protéger les joueurs contre les retards de jeu inacceptables. Des files d'attente sontrequises pour les jeux qui utilisent les flottes Spot ou la mise en relation FlexMatch. Vous pouvez créerune file d'attente de session de jeu dans n'importe quelle région.

Configuration de la mise en relation

Votre configuration qui permet de déterminer comment FlexMatch doit traiter les demandes de miseen relation. Deux paramètres de configuration clés sont le jeu de règles de mise en relation et la filed'attente de session de jeu. Le jeu de règles de mise en relation indique à GameLift comment évaluerles joueurs potentiels pour une relation. La file d'attente de session de jeu indique à GameLift oùhéberger une nouvelle session de jeu pour la relation. Vous pouvez avoir plus d'une configurationde mise en relation. Chaque demande de nouvelle relation doit spécifier la configuration de miseen relation à utiliser. Vous pouvez créer une configuration de mise en relation dans n'importe quellerégion.

Ensemble de règles de mise en relation

Vos instructions sur la manière de construire les meilleures relations possibles pour votre jeu.L'ensemble de règles définit la structure et la taille de l'équipe de la relation, et contient des règles pour

Version93

Amazon GameLift Manuel du développeur

évaluer les joueurs potentiels. Les règles peuvent définir des exigences pour des joueurs individuelsou pour des équipes entières. Un ensemble de règles peut également définir des directives poursavoir quand et comment assouplir les règles au fil du temps afin de minimiser les temps d'attente desjoueurs. Un ensemble de règles est utilisé par une configuration de mise en relation. Vous créez unensemble de règles de mise en relation dans la même région que la configuration de mise en relationqui l'utilise.

Créer des ressources à l'aide de AWSCloudFormation

Vous pouvez utiliser AWS CloudFormation pour gérer vos ressources GameLift (p. 92). La console etles commandes CLI GameLift sont des outils utiles pour créer et mettre à jour des ressources individuelles.Mais avec AWS CloudFormation, vous pouvez gérer un ensemble complet de ressources pour la prise encharge de votre hébergement de jeux. Dans AWS CloudFormation, vous créez un modèle qui modélisechaque ressource, puis vous utilisez le modèle pour créer vos ressources. Pour mettre à jour desressources, vous apportez des modifications à votre modèle et utilisez AWS CloudFormation pour mettreen œuvre les mises à jour. Vous pouvez organiser vos ressources en groupes logiques, appelés piles etensembles de piles.

L’utilisation de AWS CloudFormation pour gérer vos ressources d’hébergement GameLift constitue unemanière plus efficace de gérer des ensembles de ressources AWS. Vous pouvez utiliser le contrôle deversion pour suivre les modifications apportées au modèle au fil du temps et coordonner les mises àjour effectuées par plusieurs membres de l'équipe. Vous pouvez également réutiliser des modèles. Parexemple, lors du déploiement d'un jeu dans plusieurs régions, vous pouvez utiliser le même modèle pourcréer des ressources identiques dans chaque région. Vous pouvez également utiliser ces modèles pourdéployer les mêmes ensembles de ressources dans une autre partition.

Pour plus d'informations sur AWS CloudFormation, consultez le AWS CloudFormation Guide del'utilisateur. Pour afficher les informations sur les modèles pour des ressources GameLift, consultezRéférence de type de ressource Amazon GameLift.

Les rubriques suivantes présentent les bonnes pratiques en matière d'utilisation de AWS CloudFormationavec GameLift. Elles donnent également quelques recommandations pour structurer vos modèles deressource.

Bonnes pratiquesPour obtenir des conseils détaillés sur l'utilisation de AWS CloudFormation, consultez Bonnes pratiquesAWS CloudFormation dans le AWS CloudFormation Guide de l'utilisateur. En outre, ces bonnes pratiquesont une pertinence particulière avec GameLift.

• Gérez vos ressources de manière cohérente en utilisant uniquement AWS CloudFormation. Il s'agitd'une bonne pratique AWS CloudFormation fondamentale, mais il n’est pas inutile de le répéter. Si vousmodifiez vos ressources en dehors de AWS CloudFormation. par exemple via la console GameLift, desappels d'API ou des commandes CLI GameLift, vos ressources seront désynchronisées par rapport àvos modèles de ressource. Cela peut entraîner des conséquences inattendues lors de la prochaine miseà jour de vos ressources à l'aide des modèles AWS CloudFormation.

• Utilisez des piles et des ensembles de piles AWS CloudFormation pour gérer efficacement plusieursressources.• Utilisez des piles pour gérer des groupes de ressources connectées. AWS CloudFormation met à

jour de manière intelligente les ressources d’une pile qui se font référence les unes aux autres, selonque les propriétés de la ressource sont modifiables ou non. Par exemple, supposons que vous ayezune pile contenant une build, une flotte qui fait référence à la build et un alias qui fait référence à la

Version94

Amazon GameLift Manuel du développeurUtilisation de piles AWS CloudFormation

flotte. Dans GameLift, la relation entre les builds et les flottes est inaltérable. Si vous mettez à jourvotre modèle pour remplacer une build, AWS CloudFormation remplace également les flottes qui sontconnectées à la build remplacée. AWS CloudFormation met ensuite à jour les alias existants pourpointer vers les nouvelles flottes. Pour plus d'informations, consultez Utilisation des piles dans le AWSCloudFormation Guide de l'utilisateur.

• Utilisez des jeux de piles AWS CloudFormation si vous déployez des piles identiques dans plusieursrégions ou comptes AWS. Pour plus d'informations, consultez Utilisation des ensembles de piles dansle AWS CloudFormation Guide de l'utilisateur.

• Si vous utilisez des instances Spot, incluez une flotte à la demande comme sauvegarde. Nous vousrecommandons de configurer vos modèles avec deux flottes dans chaque région, une avec desinstances Spot et une avec des instances à la demande. La fonction FleetIQ d’GameLift garantit que lessessions de jeu sont toujours placées en premier avec des instances Spot viables. La flotte à la demandeconstitue une solution de rechange au cas où la flotte d'instances Spot n'est pas disponible.

• Regroupez vos ressources spécifiques à une région et vos ressources globales dans des piles distincteslorsque vous gérez des ressources dans plusieurs régions. Certaines ressources, telles que les flottesGameLift, peuvent uniquement faire référence à d'autres ressources dans la même région. D'autresressources, telles que les files d'attente GameLift, peuvent faire référence à des ressources dansd'autres régions. Les placer dans des piles séparées vous donne plus de flexibilité quant à l'endroit oùvous placez vos ressources globales.

• Placez vos ressources globales à proximité des services qui les utilisent. Lorsque vous placez desressources globales, gardez à l'esprit la manière dont ces ressources sont accédées. Des ressourcestelles que les files d'attente et les configurations de mise en relation ont tendance à recevoir un volumeélevé de demandes provenant de sources spécifiques, comme un service backend. En plaçant vosressources à proximité de la source de ces demandes, vous réduisez le temps de déplacement desdemandes et pouvez ainsi améliorer les performances globales.

• Placez votre configuration de mise en relation dans la même région que la file d'attente de session dejeu qu'elle utilise. Les configurations de mise en relation envoient des demandes de nouvelles sessionsde jeu dans la file d'attente. Le fait de placer ces ressources ensemble aide également à optimiser lesperformances du système.

• Créez un alias distinct pour chaque flotte de la pile. Les alias facilitent la transition du trafic des joueurslors du remplacement des builds et des flottes de jeux.

Utilisation de piles AWS CloudFormationLes structures suivantes sont recommandées pour la configuration de piles AWS CloudFormation pour lesressources associées à GameLift. Votre structure de pile optimale varie selon que vous déployez votre jeudans une seule région ou dans plusieurs régions.

Piles pour une seule régionPour gérer des ressources GameLift dans une seule région, nous recommandons une structure à deuxpiles :

• Pile de support – Cette pile contient des ressources dont dépendent vos ressources GameLift. Auminimum, cette pile doit inclure le compartiment S3 dans lequel vous stockez votre serveur de jeupersonnalisé ou vos fichiers de script Realtime. La pile doit également inclure un rôle IAM qui donne àGameLift l'autorisation de récupérer vos fichiers à partir du compartiment S3 lors de la création d'uneressource de build ou de script GameLift. Cette pile peut également contenir d'autres ressources AWSutilisées avec votre jeu, telles que des tables DynamoDB, des clusters Amazon Redshift et des fonctionsLambda.

• Pile GameLift – Cette pile contient toutes vos ressources GameLift, y compris la build ou le script, unensemble de flottes, des alias et une file d'attente de session de jeu. AWS CloudFormation crée uneressource de build ou de script avec des fichiers stockés dans l'emplacement du compartiment S3 etdéploie la build ou le script sur une ou plusieurs ressources de la flotte. Chaque flotte doit avoir un alias

Version95

Amazon GameLift Manuel du développeurUtilisation de piles AWS CloudFormation

correspondant. La file d'attente de session de jeu fait référence à tout ou partie des alias de flotte. Sivous utilisez FlexMatch pour la mise en relation, cette pile contient également une configuration de miseen relation et un jeu de règles.

Le diagramme ci-dessous illustre une structure à deux piles pour le déploiement de ressources dans uneseule région AWS.

Piles pour plusieurs régionsLorsque vous déployez votre jeu dans plusieurs régions, gardez présent à l'esprit la manière dont lesressources peuvent interagir entre les régions. Certaines ressources, telles que les flottes GameLift,peuvent uniquement faire référence à d'autres ressources dans la même région. D’autres ressources, tellesque les files d'attente GameLift, ne dépendent pas de la région. Pour gérer des ressources GameLift dansplusieurs régions, nous vous recommandons la structure suivante.

• Piles de support régionales – Ces piles contiennent des ressources dont dépendent vos GameLiftressources. Cette pile doit inclure le compartiment S3 dans lequel vous stockez votre serveur de jeupersonnalisé ou vos fichiers de script Realtime. Elle peut également contenir d'autres ressources AWSpour votre jeu, telles que des tables DynamoDB, des clusters Amazon Redshift et des fonctions Lambda.Beaucoup de ces ressources sont spécifiques à la région, vous devez donc les créer dans chaquerégion. GameLift a également besoin d'un rôle IAM qui permette l'accès à ces ressources de support. Unrôle IAM ne dépendant pas de la région, vous avez besoin d'une seule ressource de rôle, placée dansn’importe quelle région et référencée dans toutes les autres piles de support.

• Piles GameLift régionales– Cette pile contient les ressources GameLift qui doivent exister dans chaquerégion où votre jeu est déployé, y compris la build ou le script, un ensemble de flottes et des alias. AWSCloudFormation crée une ressource de build ou de script avec des fichiers dans un emplacement decompartiment S3, et déploie la build ou le script sur une ou plusieurs ressources de la flotte. Chaqueflotte doit avoir un alias correspondant. La file d'attente de session de jeu fait référence à tout ou partiedes alias de flotte. Vous pouvez gérer un modèle pour décrire ce type de pile et l'utiliser pour créer desensembles de ressources identiques dans chaque région.

Version96

Amazon GameLift Manuel du développeurUtilisation de piles AWS CloudFormation

• Pile GameLift globale – Cette pile contient votre file d'attente de session de jeu et les ressources demise en relation. Ces ressources peuvent être situées dans n'importe quelle région et sont généralementplacées dans la même région. La file d'attente peut faire référence à des flottes ou à des alias situésdans n'importe quelle région. Pour placer des files d'attente supplémentaires dans différentes régions,créez des piles globales supplémentaires.

Les diagrammes ci-dessous illustrent une structure à plusieurs piles pour le déploiement de ressourcesdans plusieurs régions AWS. Le premier diagramme montre une structure pour une file d'attente de sessionde jeu unique. Le deuxième diagramme montre une structure avec plusieurs files d'attente.

Version97

Amazon GameLift Manuel du développeurUtilisation de piles AWS CloudFormation

Version98

Amazon GameLift Manuel du développeurMise à jour des builds

Mise à jour des buildsLes builds GameLift sont immuables, tout comme la relation entre une build et une flotte. Par conséquent,lorsque vous mettez à jour vos ressources d'hébergement pour utiliser un nouvel ensemble de fichiers debuild de jeu, les étapes suivantes doivent être exécutées :

• Créez une nouvelle build en utilisant le nouvel ensemble de fichiers (remplacement).• Créez un nouvel ensemble de flottes pour déployer la nouvelle build de jeu (remplacement).

Version99

Amazon GameLift Manuel du développeurMise à jour des builds

• Redirigez les alias pour pointer vers les nouvelles flottes (mise à jour sans interruption).

Pour plus d’informations, consultez Comportements de mise à jour des ressources d'une pile dans le AWSCloudFormation Guide de l'utilisateur.

Déploiement automatique des mises à jour de buildLors de la mise à jour d'une pile contenant des ressources de build, de flotte et d'alias associées, lecomportement AWS CloudFormation par défaut consiste à effectuer automatiquement ces étapes dansl'ordre. Vous déclenchez cette mise à jour en téléchargeant d'abord les nouveaux fichiers de build vers unnouvel emplacement S3. Ensuite, vous modifiez votre modèle de build AWS CloudFormation pour pointervers le nouvel emplacement S3. Lorsque vous mettez à jour votre pile avec le nouvel emplacement S3, laséquence AWS CloudFormation suivante se déclenche :

1. Récupération des nouveaux fichiers depuis S3, validation des fichiers et création d’un nouvelle buildGameLift.

2. Mise à jour de la référence de build dans le modèle de flotte, ce qui déclenche la création d'une nouvelleflotte.

3. Lorsque les nouvelles flottes sont actives, mise à jour de la référence de flotte dans l'alias, ce quidéclenche la mise à jour de l'alias pour cibler les nouvelles flottes.

4. Suppression de l'ancienne flotte.5. Suppression de l'ancienne build.

Si votre file d'attente de session de jeu utilise des alias de flotte, le trafic des joueurs est automatiquementbasculé vers les nouvelles flottes dès que les alias sont mis à jour. Les anciennes flottes sontprogressivement vidées de leurs joueurs à mesure que les sessions de jeu se terminent. La mise àl'échelle automatique gère la tâche d'ajout et de suppression des instances à partir de chaque ensemble deflottes lorsque le trafic des joueurs fluctue. Vous pouvez également spécifier un nombre d'instances initialsouhaité pour accélérer rapidement la montée en charge du commutateur et activer la mise à l'échelleautomatique ultérieurement.

Vous pouvez également demander que AWS CloudFormation conserve les ressources au lieu de lessupprimer. Pour plus d'informations, consultez RetainResources dans le AWS CloudFormation APIReference.

Déploiement manuel des mises à jour de buildSi vous souhaitez contrôler davantage le moment où les nouvelles flottes sont en ligne pour les joueurs,vous disposez de plusieurs options. Vous pouvez choisir de gérer manuellement les alias à l'aide de laconsole ou de l'interface de ligne de commande GameLift. Au lieu de mettre à jour votre modèle de buildpour remplacer la build et les flottes, vous pouvez ajouter un deuxième ensemble de définitions de build etde flotte à votre modèle. Lorsque vous mettez à jour le modèle, AWS CloudFormation crée une deuxièmeressource de build et les flottes correspondantes. Les ressources existantes n’étant pas remplacées, ellesne sont pas supprimées et les alias continuent de pointer vers les flottes d'origine.

Le principal avantage de cette approche est qu'elle vous donne de la flexibilité. Vous pouvez créer desressources distinctes pour la nouvelle version de votre build, tester les nouvelles ressources et contrôlerle moment où les nouvelles flottes sont mises en ligne pour les joueurs. Un inconvénient potentiel est quecela nécessite deux fois plus de ressources dans chaque région pendant une brève période.

Le schéma suivant illustre ce processus.

Version100

Amazon GameLift Manuel du développeurChargement des builds et scripts

Fonctionnement des restaurationsLors de l'exécution d'une mise à jour des ressources, si une étape ne se termine pas correctement, AWSCloudFormation lance automatiquement une restauration. Ce processus inverse chaque étape dans l'ordre,en supprimant les ressources nouvellement créées.

Si vous devez déclencher manuellement une restauration, restaurez l’emplacement d’origine de la cléd'emplacement S3 du modèle de build, puis mettez à jour votre pile. Une nouvelle build et une nouvelleflotte GameLift sont créées, et l'alias bascule vers la nouvelle flotte une fois la flotte active. Si vous gérezdes alias séparément, vous devez les modifier de sorte qu’ils pointent vers les nouvelles flottes.

Pour plus d'informations sur la façon de gérer une restauration qui échoue ou se bloque, consultezPoursuite de la restauration d'une mise à jour dans le AWS CloudFormation Guide de l'utilisateur.

Chargement de builds et de scripts sur GameLiftAvant de déployer votre GameLiftServeurs de jeux multijoueur compatibles avec pour l’hébergementavec l’ GameLift , vous devez charger les fichiers de votre serveur de jeux. Les rubriques de cette sectionfournissent des conseils sur la préparation et le chargement de fichiers de build de serveur de jeuxpersonnalisés ou de fichiers de script serveur Serveurs en temps réel. Lorsque vous chargez des fichiers,vous créez un GameLift des ressources de génération ou de script, que vous déployez ensuite sur lesparcs de ressources d’hébergement.

Rubriques• Charger une build de serveur personnalisée sur GameLift (p. 101)• Chargement d'un Serveurs en temps réel script dansGameLift (p. 107)

Charger une build de serveur personnalisée surGameLiftUne fois que votre serveur de jeux a été intégré à GameLift, téléchargez les fichiers de build sur le serviceGameLift géré afin qu'il puisse être déployé pour l'hébergement de jeux. Cette rubrique explique commentcréer un package avec vos fichiers de build de jeu, créer un script d'installation de build facultatif, puischarger les fichiers à l'aide de l'interface de ligne de commande AWS ou du kit de développement logicielAWS.

Version101

Amazon GameLift Manuel du développeurTélécharger une build de serveur personnalisée

Ajouter un script d'installation de buildCréez un script d'installation pour le système d'exploitation de votre version de génération de jeu :

• Windows : créez un fichier de commandes nommé « install.bat ».• Linux : créez un fichier de script shell nommé « install.sh ».

Lors de la création d'un script d'installation, gardez à l'esprit les informations suivantes :

• Le script ne peut pas prendre en charge les informations fournies par l'utilisateur.• Une build est installée sur un serveur d'hébergement aux emplacements suivants. Les répertoires de

fichiers de votre package de build sont recréés.• Pour les flottes Windows : C:\game• Pour les flottes Linux : /local/game

• Pendant le processus d'installation, l'utilisateur run-as dispose d'un accès limité à la structure defichier d'instance. Il dispose de l'intégralité des droits sur le répertoire dans lequel vos fichiers de buildsont installés. Si votre script d'installation procède à des opérations nécessitant des autorisationsd'administrateur, vous devez spécifier un accès administrateur (sudo pour Linux, runas pour Windows).Les échecs d'autorisation liés au script d'installation génèrent un message d'événement indiquant unproblème avec le script.

• Sous Linux, les langages d'interpréteur shell courants tels que bash sont pris en charge. Ajoutez unpackage (par exemple, #!/bin/bash) en haut de votre script d'installation. Si vous devez vérifier laprise en charge de vos commandes shell préférées, vous pouvez accéder à distance à une instanceLinux active et ouvrir une invite du shell. Découvrez-en plus sur Accès à distance aux instances de flotteGameLift (p. 130).

• Le script d'installation ne peut pas s'appuyer sur une connexion d'appairage VPC. Si vous prévoyez deconfigurer l'appairage VPC lors de la création de flottes pour cette génération, cette connexion n'estdisponible qu'après l'installation de la génération sur les instances de flotte.

Exemples de script

Ces exemples illustrent l'utilisation courante des scripts pour Windows et Linux.

Windows:

Cet exemple de fichier install.bat installe les composants d'exécution Visual C++ requis pour le serveur dejeux et écrit les résultats dans un fichier journal. Le fichier de composants est inclus dans le package de labuild, à la racine.

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

Linux*

Cet exemple de fichier install.sh illustre l'utilisation de bash dans votre script d'installation et l'écriture desrésultats dans un fichier journal.

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

Conditionner les fichiers de version de jeuAvant de charger votre serveur de jeux compatible GameLift vers le service GameLift en vue de sonhébergement, vous devez regrouper tous les fichiers de build de jeu dans un répertoire de build. Ce

Version102

Amazon GameLift Manuel du développeurTélécharger une build de serveur personnalisée

répertoire doit inclure tous les composants nécessaires pour l'exécution de vos serveurs de jeux etl'hébergement de sessions, y compris les éléments suivants :

• Fichiers binaires du serveur de jeux – Fichiers binaires requis pour exécuter le serveur de jeux. Uneversion de génération peut inclure les fichiers binaires de plusieurs serveurs de jeux, dès lors qu'ils sontconçus pour une exécution sur la même plateforme (consultez les plateformes prises en charge (p. 27)).

• Dépendances – Fichiers dépendants requis par les exécutables de votre serveur de jeux pour leurexécution. Exemples : actifs, fichiers de configuration et bibliothèques dépendantes.

• Script d'installation – Fichier de script permettant de gérer les tâches nécessaires à l'installation complètede la build de votre jeu sur les serveurs d'hébergement d'GameLift. Ce fichier doit être placé à la racinedu répertoire de builds. Un script d'installation est exécuté une fois dans le cadre de la création desflottes.

Vous pouvez configurer n'importe quelle application de votre build, y compris votre script d'installation,pour accéder en toute sécurité à vos ressources dans d'autres services AWS. Découvrez d'autres façonspossibles de faire ceci dans Communiquez avec d’autres ressources AWS de vos flottes (p. 49).

Une fois que vous avez packagé les fichiers de votre build, assurez-vous que votre serveur de jeux peuts'exécuter sur une installation propre de votre système d'exploitation cible (pas sur un système qui a étéutilisé pour le développement). Cette étape permet de s'assurer que vous incluez toutes les dépendancesnécessaires dans votre package et que votre script d'installation est exact.

Note

Si vous stockez les fichiers de la build de votre jeu dans un compartiment Amazon S3 en vuedu chargement, vous devez placer tous les fichiers de la build dans un fichier .zip. Voustrouverez des instructions de chargement à l'aide de cette méthode dans Création d'une versionde génération avec des fichiers dans Amazon S3 (p. 105).

Créer une build GameLiftLorsque vous créez une build et téléchargez vos fichiers, vous disposez de quelques options :

• Créer une build à partir d'un répertoire de fichiers (p. 104). Il s’agit de la méthode la plus simple et laplus couramment utilisée.

• Création d'une version de génération avec des fichiers dans Amazon S3 (p. 105). Avec cette option,vous pouvez gérer vos versions de génération dans S3 sous votre compte AWS.

Avec les deux méthodes, une nouvelle ressource de build est créée avec un ID unique et d'autresmétadonnées. La version est placée dans l'état Initialisée. Lorsque l'acquisition des fichiers du serveur dejeux est correctement effectuée par GameLift, la build passe à l’état Ready (Prêt). À ce stade, vous pouvezla déployer en créant une nouvelle flotte GameLift (consultez Déployer une flotte GameLift pour une buildde jeu personnalisée (p. 116)).

Lorsque vous créez une flotte, vous spécifiez la build à déployer sur la flotte. Lorsqu’GameLift configurela nouvelle flotte, il télécharge les fichiers de build sur chaque instance de flotte et les installe en fonctiondu script d'installation de build (le cas échéant). Les fichiers de build sont installés sur les instances auxemplacements suivants :

• Pour les flottes Windows : C:\game• Pour les flottes Linux : /local/game

Version103

Amazon GameLift Manuel du développeurTélécharger une build de serveur personnalisée

Créer une build à partir d'un répertoire de fichiers

Pour créer une build de jeu avec des fichiers du serveur de jeux assemblés et stockés dans n'importe quelemplacement, y compris dans un répertoire local, utilisez la commande upload-build de l'AWS CommandLine Interface (AWS CLI). Cette commande crée un enregistrement de build dans GameLift et charge lesfichiers depuis un emplacement que vous spécifiez.

1. Envoyez une demande de chargement. Dans une fenêtre de ligne de commande, saisissez lacommande et les paramètres suivants.

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 – Chemin d’accès au répertoire de vos fichiers de build.• Operating system – Spécifiez le système d'exploitation de la build du serveur de jeu. Lorsqu'une

nouvelle flotte est créée pour cette build, les instances de flotte sont configurées avec le systèmed'exploitation approprié. GameLift prend en charge plusieurs versions de Windows et Linux. Ceparamètre est facultatif. Si aucun système d'exploitation n'est spécifié, GameLift utilise la valeurpar défaut (WINDOWS_2012). Une fois la build créée, cette valeur ne peut pas être mise à jourultérieurement.

• Name – Fournissez un nom descriptif pour cette nouvelle build. Le nom de build n'a pas besoind'être unique, et vous pouvez mettre à jour cette valeur à tout moment en mettant à jour la ressourcede build.

• Build version – Utilisez ce champ facultatif pour spécifier les détails de version des fichiers de build.Chaque nouvelle version de votre serveur de jeu nécessitant une nouvelle ressource de build, cesinformations peuvent fournir un outil de différenciation précieux.

• Region – Identifiez la région prise en charge par GameLift dans laquelle vous souhaitez créer votrebuild. Vous devez créer la build dans la région dans laquelle vous prévoyez de déployer des flottes.Si vous déployez votre jeu dans plusieurs régions, vous devez créer une build dans chaque région.

Note

Si vous travailler dans plusieurs régions, il est conseillé de vérifier la région enregistrée pardéfaut. Dans la console AWS, la région actuelle est toujours affichée dans le coin supérieurdroit, avec une liste déroulante des régions disponibles à sélectionner. Si vous utilisezl'interface de ligne de commande AWS, vérifiez votre valeur par défaut actuelle à l'aide deconfigure get (aws configure get region). Utilisez la commande configure set (awsconfigure set region [region name]) pour modifier votre région par défaut.

En réponse à votre demande de chargement, le service GameLift indique l'avancement duchargement, ainsi que l'ID du nouvel enregistrement de la version de build lorsque le chargementest réussi. Le temps de chargement dépend de la taille de vos fichiers de jeu et de la vitesse deconnexion.

Exemples :

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

Version104

Amazon GameLift Manuel du développeurTélécharger une build de serveur personnalisée

2. Vérifiez le statut de la build. Affichez le nouvel enregistrement de build, y compris le statut actuel, àl'aide de describe-build (ou DescribeBuild). Vous pouvez également consulter l'état sur la consoleGameLift.

Dans une fenêtre de ligne de commande, saisissez la commande et les paramètres suivants.

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

Exemple:

aws gamelift describe-build --build-id "build-3333cccc-44dd-55ee-66ff-7777aaaa88bb" --region us-west-2

En réponse à votre demande, le service GameLift renvoie l'enregistrement de build demandé. Cetenregistrement contient un ensemble de métadonnées de la build, y compris l'état, la taille des fichierstéléchargés et un horodatage de création.

Création d'une version de génération avec des fichiers dans Amazon S3

Pour créer un enregistrement de jeu avec des fichiers de serveur de jeux assemblés et stockés dans uncompartiment Amazon S3 de votre compte AWS, utilisez la commande create-build de l'AWS CLI. Cetteopération crée une nouvelle build dans GameLift et acquiert vos fichiers de build dans le compartimentAmazon S3 que vous spécifiez.

1. Stockez vos fichiers de génération dans Amazon S3. Créez un fichier .zip contenant les fichiers debuild assemblés et chargez-le dans un compartiment Amazon S3 de votre compte AWS. Prenez notede l’étiquette du compartiment et du nom du fichier ; vous en aurez besoin lors de la création d’unGameLift génération.

2. Donner GameLift accès à vos fichiers de génération. Suivez les instructions de Configuration d'unrôle pour lGameLift'accès (p. 26) pour créer un rôle IAM. Un rôle spécifie les entités (par exemple, leservice GameLift) pouvant assumer le rôle et définit un ensemble d'autorisations pour un accès limitéà vos ressources AWS. Une fois que vous avez créé le rôle, notez le nouveau nom Amazon ResourceName (ARN). Vous en aurez besoin lors de la création d'une build.

3. Envoyez une demande pour créer une nouvelle build. Utilisez la commande de l’AWS CLI create-build(ou l'opération du kit de développement logiciel AWS CreateBuild) pour créer un nouvel enregistrementde build. Spécifiez l'emplacement S3 où vos fichiers de build sont stockés. Dans une fenêtre de lignede commande, saisissez la commande et les paramètres suivants.

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]

• Build root – Chemin d’accès au répertoire de vos fichiers de build.• Operating system – Spécifiez le système d'exploitation de la build du serveur de jeu. Lorsqu'une

nouvelle flotte est créée pour cette build, les instances de flotte sont configurées avec le systèmed'exploitation approprié. GameLift prend en charge plusieurs versions de Windows et Linux. Ceparamètre est facultatif. Si aucun système d'exploitation n'est spécifié, GameLift utilise la valeurpar défaut (WINDOWS_2012). Une fois la build créée, cette valeur ne peut pas être mise à jourultérieurement.

• Name – Fournissez un nom descriptif pour cette nouvelle build. Le nom de build n'a pas besoind'être unique, et vous pouvez mettre à jour cette valeur à tout moment en mettant à jour la ressourcede build.

Version105

Amazon GameLift Manuel du développeurTélécharger une build de serveur personnalisée

• Build version – Utilisez ce champ facultatif pour spécifier les détails de version des fichiers de build.Chaque nouvelle version de votre serveur de jeu nécessitant une nouvelle ressource de build, cesinformations peuvent fournir un outil de différenciation précieux.

• Emplacement &S3;• Bucket – Nom du compartiment S3 qui contient votre build. Exemple : « my_build_files ».• Key – Nom du fichier .zip qui contient vos fichiers de build. Exemple : « mygame_build_7.0.1,

7.0.2 ».• Role ARN – ARN attribué au rôle IAM que vous avez créé. Exemple :

« arn:aws:iam::111122223333:role/GameLiftAccess ».• Region – Identifiez la région prise en charge par GameLift dans laquelle vous souhaitez créer votre

build. Vous devez créer la build dans la région dans laquelle vous prévoyez de déployer des flottes.Si vous déployez votre jeu dans plusieurs régions, vous devez créer une build dans chaque région.

Note

Si vous travailler dans plusieurs régions, il est conseillé de vérifier la région enregistrée pardéfaut. Dans la console AWS, la région actuelle est toujours affichée dans le coin supérieurdroit, avec une liste déroulante des régions disponibles à sélectionner. Si vous utilisezl'interface de ligne de commande AWS, vérifiez votre valeur par défaut actuelle à l'aide deconfigure get (aws configure get region). Utilisez la commande configure set (awsconfigure set region [region name]) pour modifier votre région par défaut.

Exemple:

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

En réponse à votre demande, le service GameLift renvoie l'enregistrement de build nouvellement créé,y compris l'état actuel de la build.

Mise à jour de vos fichiers de version de générationUne fois qu’un GameLift La génération a été créée, les fichiers de génération associés ne peuvent pas êtremodifiés. Au lieu de cela, vous devez créer une nouvelle build GameLift pour chaque nouvel ensemblede fichiers. Si vous fournissez des fichiers de build à l'aide de la commande upload-build, aucuneaction n'est requise de votre part, car GameLift crée automatiquement un nouvel enregistrement de buildpour chaque demande. Si vous fournissez des fichiers de build à l'aide de la commande create-build,chargez un nouveau fichier de build .zip portant un nom différent dans Amazon S3 et créez une build enréférençant le nom du nouveau fichier.

Pour déployer des versions de génération mises à jour, voici quelques astuces :

• Utilisez les files d'attente et remplacez des flottes selon vos besoins. Lorsque vous configurez votre clientde jeu avec GameLift, spécifiez une file d'attente au lieu d'une flotte. Avec les files d'attente, vous pouvezcréer de nouvelles flottes pour exécuter votre nouvelle version, puis les ajouter à votre file d'attente etsupprimer les anciennes. Pour de plus amples informations, veuillez consulter Utilisation de files d'attentesur plusieurs régions (p. 143).

• Utilisez des alias pour transférer facilement les joueurs vers une nouvelle version de jeu. Lorsque vousintégrez votre client de jeu à GameLift, spécifiez un alias de flotte au lieu d'un ID de flotte. Avec les alias,vous pouvez déplacer les joueurs vers une nouvelle génération en seulement trois étapes : (1) Créez lanouvelle build. (2) Créer une flotte pour déployer la nouvelle version de génération. (3) Changer la cibled'alias de l'ancienne à la nouvelle flotte. Pour plus d'informations, consultez Ajouter un alias à une flotteGameLift (p. 126),

Version106

Amazon GameLift Manuel du développeurChargement d'un Serveurs en temps réel script

• Configurez l'automatisation des mises à jour des versions de génération. Suivez l’article du blogGameTech Automatisation des déploiements vers GameLift, avec des exemples de scripts, à intégrerGameLift dans votre système de génération.

Chargement d'un Serveurs en temps réel scriptdansGameLiftLorsque vous êtes prêt à déployer Serveurs en temps réel pour votre jeu, chargez les fichiers de scriptde RealTime serveur terminés dans GameLift . Pour ce faire, créez une ressource GameLift de script etspécifiez l'emplacement de vos fichiers de script. Vous pouvez également mettre à jour les fichiers de scriptde serveur déjà déployés en chargeant de nouveaux fichiers pour une ressource de script existante.

Lorsque vous créez une nouvelle ressource de script, GameLift attribue un ID de script unique (parexemple : script-1111aaaa-22bb-33cc-44dd-5555eeee66ff ) et charge une copie des fichiers descript. Le temps de chargement dépend de la taille de vos fichiers de script et de la vitesse de connexion.

Une fois la ressource de script créée, elle peut être déployée avec une nouvelle GameLift Serveurs entemps réel flotte. GameLift installe votre script de serveur sur chaque instance de la flotte, en plaçant lesfichiers de script à l'emplacement suivant : /local/game.

Pour résoudre les problèmes d'activation d'une flotte qui peuvent être associés au serveur de script,consultez Déboguer les incidents de flotte GameLift (p. 127).

Fichiers de script de packageVotre script de serveur peut inclure un ou plusieurs fichiers combinés en un seul .zip fichier pour lechargement. Le fichier zip doit contenir tous les fichiers dont votre script dépend pour s'exécuter.

Pour le chargement, vous pouvez stocker vos fichiers de script compressés dans un répertoire de fichierlocal ou dans un Amazon S3 compartiment .

Charger des fichiers de script à partir d'un répertoire localSi vos fichiers de script sont stockés localement, vous pouvez choisir de les charger vers GameLift à partirde là. Pour créer la ressource de script, utilisez la GameLift console ou l'outil de l'interface de ligne decommande AWS.

GameLift Console

Pour créer une ressource de script

1. Ouvrez la console Amazon GameLift à l'adresse https://console.aws.amazon.com/gamelift/.2. Utilisez le menu GameLift principal pour ouvrir Scripts : Page Créer un script. Cette page contient

le formulaire de création de script.3. Dans Script configuration (Configuration de script), entrez un nom de script et des informations de

version. Comme le contenu d'un script peut être mis à jour, les données de version peuvent êtreutiles pour le suivi des mises à jour.

4. Dans Script code (Code de script), choisissez le Script type (Type de script) « Fichier zip ». Cetteoption vous permet de spécifier un fichier zip qui est stocké dans un répertoire local.

5. Recherchez le fichier zip qui contient votre script et sélectionnez-le.6. Une fois que vous avez fini de définir le nouvel enregistrement de script, cliquez sur Submit:

GameLift attribue un ID au nouveau script et commence à charger le fichier zip désigné. Vouspouvez voir le nouvel enregistrement de script, y compris le statut, sur la pageScripts de laconsole.

Version107

Amazon GameLift Manuel du développeurChargement d'un Serveurs en temps réel script

AWS CLI

Pour créer un script avec l'AWS CLI, ouvrez une fenêtre de ligne de commande et utilisez lacommande create-script pour définir le nouveau script et charger vos fichiers de script de serveur.Consultez la documentation complète sur cette commande dans la Référence des commandes d'AWSCLI. Obtenez et installez l'outil AWS Command Line Interface..

Pour créer une ressource de script

1. Placez le fichier zip dans un répertoire où vous pouvez effectuer des appels à l'interface de lignede commande AWS.

2. Dans une fenêtre de ligne de commande, accédez au répertoire où se trouve le fichier zip.3. Saisissez la commande create-script et les paramètres. Pour le paramètre -zip-file,

veillez à préfixer la chaîne « fileb :// » dans le nom du fichier zip. Elle identifie le fichier commebinaire et s'assure que le contenu compressé sera traité correctement.

aws gamelift create-script --name [user-defined name of script] --script-version [user-defined version info] --zip-file fileb://[name of zip file] --region [region name]

En réponse à votre demande, le GameLift service Amazon renvoie le nouvel objet de script.

Exemples :

aws gamelift create-script --name My_Realtime_Server_Script_1 --script-version 1.0.0 --zip-file fileb://myrealtime_script_1.0.0.zip --region us-west-2

Vous pouvez afficher le nouveau script en appelant describe-script ou en l'affichant dans la GameLiftconsole Amazon.

Chargement des fichiers de script dansAmazon S3Vous pouvez choisir de stocker vos fichiers de script dans un compartiment Amazon S3 et les charger dansGameLift à partir de là. Lorsque vous créez votre script, vous spécifiez l'emplacement du compartiment S3et Amazon GameLift acquiert vos fichiers de script directement à partir de S3.

Pour créer une ressource de script

1. Stockez vos fichiers de script dans un Amazon S3 compartiment . Créez un fichier .zip contenant vosfichiers de script de serveur et chargez-le dans un Amazon S3 compartiment d'un compte AWS quevous contrôlez. Notez le nom du compartiment et le nom du fichier (également appelé « clé »). Vousen aurez besoin lors de la création d'un GameLift script.

Note

ne prend GameLift actuellement pas en charge le chargement à partir de Amazon S3compartiments dont les noms contiennent un point (.).

2. Accordez à GameLift l'accès à vos fichiers de script. Suivez les instructions de la section Configurationd'un rôle pour lGameLift'accès (p. 26) pour créer un rôle IAM qui permet à GameLift d'accéder aucompartiment Amazon S3 contenant votre script de serveur. Une fois que vous avez créé le rôle, notezle nouveau nom Amazon Resource Name (ARN). Vous en aurez besoin lors de la création d'un script.

3. Créez un script. Pour créer un nouvel enregistrement de script, vous pouvez utiliser la console oul'outil interface de ligne de commande AWS. Pour effectuer cette demande, vous devez disposer dePassRole l'autorisation IAM, comme décrit dans Exemples de stratégies IAM pour GameLift (p. 24) .

Version108

Amazon GameLift Manuel du développeurChargement d'un Serveurs en temps réel script

GameLift Console

1. Utilisez le menu GameLift principal pour ouvrir Scripts : Page Créer un script pour accéder auformulaire de création de script.

2. Dans Script configuration (Configuration de script), entrez un nom de script et des informations deversion. Comme le contenu d'un script peut être mis à jour, les données de version peuvent êtreutiles pour le suivi des mises à jour.

3. Dans Script code (Code de script), choisissez le Script type (Type de script) « Stockageutilisateur ». Cette option vous permet de spécifier le compartiment S3 contenant votre fichier descript.

4. Saisissez les informations relatives à l'emplacement de stockage de votre compartiment S3 :

• Compartiment S3 – Le nom du compartiment.• Clé S3 – Le nom du fichier (fichier compressé contenant votre script de serveur) dans le

compartiment.• ARN du rôle S3 – La valeur ARN du rôle IAM que vous avez créé à l'étape 2.• Version objet S3 – (facultatif) Un numéro de version spécifique pour le fichier S3. Il est

uniquement utilisé lorsque la gestion des versions d'objets est activée dans le compartiment S3ET lorsque vous souhaitez spécifier une version autre que la dernière.

5. Une fois que vous avez achevé de définir les nouvel enregistrement de script, cliquez surSubmit (Envoyer). GameLift attribue une ID au nouveau script et lance le chargement du fichierzip désigné. Vous pouvez voir le nouvel enregistrement de script, y compris le statut, sur lapageScripts de la console.

AWS CLI

Utilisez la commande create-script pour définir le nouveau script et charger vos fichiers descript de serveur. Consultez la documentation complète sur cette commande dans la Référence descommandes d'AWS CLI. Obtenez et installez l'outil AWS Command Line Interface..

1. Ouvrez une fenêtre de ligne de commande et accédez à un répertoire où vous pouvez utiliserl'outil d'interface de ligne de commande AWS.

2. Entrez la create-script commande avec les paramètres suivants : --name, et --script-version .--storage-location Le paramètre d'emplacement de stockage spécifiel'emplacement du Amazon S3 compartiment de vos fichiers de script.

aws gamelift create-script --name [user-defined name of script] --script-version [user-defined version info] --storage-location "Bucket=[S3 bucket name],Key=[name of zip file in S3 bucket],RoleArn=[Access role ARN]" --region [region name]

En réponse à votre demande, le GameLift service Amazon renvoie le nouvel objet de script.

Exemples :

aws gamelift create-script --name My_Realtime_Server_Script_1 --script-version 1.0.0 --storage-location "Bucket=gamelift-script,Key=myrealtime_script_1.0.0.zip,RoleArn=arn:aws:iam::123456789012:role/S3Access" --region us-west-2

Vous pouvez afficher le nouveau script en appelant describe-script ou en l'affichant dans laGameLift console Amazon.

Version109

Amazon GameLift Manuel du développeurConfiguration de flottes

Mise à jour des fichiers de scriptVous pouvez mettre à jour les métadonnées d'une ressource de script à l'aide de la GameLift console oude l'interface de ligne de commande AWS update-script.

Vous pouvez également mettre à jour le contenu d'un script. Le contenu de script mis à jour est déployé surtoutes les instances de flotte qui utilisent la ressource de script mise à jour. Une fois déployé, le script misà jour est utilisé lors du démarrage de nouvelles sessions de jeu. Cela n'affecte pas les sessions de jeu quisont déjà en cours d'exécution au moment de la mise à jour.

Pour mettre à jour les fichiers de script :

• Pour les fichiers de script stockés localement : Pour charger le GameLift fichier de script mis à jour,utilisez la console ou le script de .zip mise à jour de la commande de l'interface de ligne de commandeAWS.

• Pour les fichiers de script stockés dans un Amazon S3 compartiment : Chargez les fichiers de script misà jour dans le compartiment. Amazon vérifie GameLift régulièrement les fichiers de script mis à jour et lesacquiert directement à partir du compartiment S3.

Vous pouvez également modifier l'emplacement où se trouve le contenu de script sans avoir à créer unnouvel enregistrement de script.

Configuration de flottes GameLiftCette section fournit une aide détaillée pour la conception, la construction et la maintenance de flottes àutiliser avec une solution GameLift gérée. Les flottes GameLift gérées sont utilisées pour déployer desserveurs de jeu personnalisés et Serveurs en temps réel.

Les flottes sont vos ressources d'hébergement sous la forme d'un ensemble d'instances EC2. La taille d'unparc dépend du nombre d'instances que vous lui accordez, et vous pouvez ajuster la taille du parc afin derépondre à la demande des joueurs manuellement ou avec la scalabilité automatique.

La plupart des jeux en production nécessitent plusieurs flottes. Si, par exemple, vous souhaitez hébergerdes joueurs dans plusieurs régions, ou si vous avez deux ou plusieurs versions de votre version degénération ou script de serveur de jeux (comme des versions gratuites ou payantes), vous aurez besoind'avoir plusieurs flottes.

Pour en savoir plus sur la façon de créer des flottes qui répondent le mieux à vos besoins de jeu,commencez par Guide de conception de flotte GameLift (p. 110). Lorsque votre flotte est opérationnelle,vous pouvez créer un alias de flotte (p. 126), ajouter la flotte à une file d'attente de sessions dejeu (p. 143) et gérer la capacité de la flotte (p. 133).

Conseil

Informez-vous sur les façons d'explorer les fonctions Amazon GameLift, en particulier Serveurs entemps réel, à l'aide des exemples de jeux. (p. 32).

Guide de conception de flotte GameLiftCe guide de conception couvre les principaux points de décision lors de la création d'une flotte deressources d'hébergement à utiliser avec une solution GameLift gérée. Sélectionnez la bonne combinaisonde ressources d'hébergement et apprenez à les configurer en fonction de votre jeu.

Conseil

Informez-vous sur les façons d'explorer les fonctions Amazon GameLift, en particulier Serveurs entemps réel, à l'aide des exemples de jeux. (p. 32).

Version110

Amazon GameLift Manuel du développeurGuide de conception de flotte

Rubriques• Choisir des ressources informatiques (p. 111)• Exécution de plusieurs processus sur une flotte GameLift (p. 113)• Utilisation d'instances Spot avec GameLift (p. 115)

Choisir des ressources informatiquesGameLift utilise des ressources Amazon Elastic Compute Cloud (Amazon EC2), appelées instances, pourdéployer vos serveurs de jeux et héberger les sessions de jeu de vos joueurs. Lors de la configurationd'une nouvelle flotte, vous déterminez le type d'instances dont votre jeu a besoin et comment exécuter lesprocessus serveur de jeux sur celles-ci (via la configuration d'exécution). Dès qu'une flotte est active etprête à héberger des sessions de jeu, vous pouvez ajouter ou retirer des instances à tout moment pouraccueillir plus ou moins de joueurs. Toutes les instances d'une flotte utilisent le même type de ressourceset la même configuration d'exécution. Vous pouvez modifier la configuration d'exécution d'une flotte, maisle type de ressources ne peut pas être modifié.

Lorsque vous choisissez les ressources d'une flotte, vous devez tenir compte de plusieurs facteurs,comme le système d'exploitation du jeu, le type d'instance (matériel informatique), et s'il convient d'utiliserdes instances à la demande ou des instances Spot. Gardez à l'esprit que les coûts d'hébergement avecGameLift dépendent essentiellement du type de ressources que vous utilisez. En savoir plus sur latarification GameLift.

Operating systems

GameLift prend en charge les builds de serveur de jeux qui s'exécutent sur Microsoft Windows ouAmazon Linux (consultez les systèmes d'exploitation de serveur de jeux pris en charge (p. 27)). Lors dutéléchargement d'une build de jeu dans GameLift, vous devez indiquer le système d'exploitation du jeu.Lorsque vous créez une flotte pour déployer la build du jeu, GameLift configure automatiquement lesinstances avec le système d'exploitation de la build.

Le coût des ressources dépend du système d'exploitation utilisé. En savoir plus sur les ressourcesdisponibles pour les systèmes d'exploitation pris en charge :

• Microsoft Windows• Amazon Linux

Types d'instance

Le type d'instance d'une flotte détermine le type de matériel qui sera utilisé pour chaque instance dela flotte. Les types d'instance offrent plusieurs combinaisons de puissance de calcul, de mémoire, destockage et de mise en réseau. Avec GameLift, vous avez le choix d'un grand nombre d'options de typed'instance. Consultez la liste des types d'instance disponibles ou ouvrez la page Limites de service sur laconsole GameLift afin d'afficher les types d'instance, l'utilisation en cours et les limites d'utilisation. Pour ensavoir plus sur les capacités de chaque type d'instance, consultez la section Types d'instances AmazonEC2. Notez que les types d'instance proposés peuvent varier en fonction de la région.

Lorsque vous choisissez un type d'instance pour votre jeu, tenez compte des éléments suivants : (1) lesexigences de calcul de votre build de serveur de jeux, et (2) le nombre de processus serveur que vousprévoyez d'exécuter sur chaque instance. Vous pouvez éventuellement exécuter plusieurs processusserveur sur chaque instance en utilisant un type d'instance plus grand, ce qui permet de réduire le nombred'instances dont vous avez besoin pour répondre à la demande des joueurs. Toutefois, les types d'instanceplus grands sont également plus coûteux. En savoir plus sur l'exécution de plusieurs processus sur uneflotte (p. 113).

Version111

Amazon GameLift Manuel du développeurGuide de conception de flotte

Instances À la demande et Instances Spot

Lorsque vous créez une nouvelle flotte, vous désignez le type de flotte en utilisant des instances à lademande ou des instances Spot. Les instances à la demande et les instances Spot offrent exactementle même matériel et les mêmes performances, en fonction du type d'instance choisie, et elles sontconfigurées de façon identique. Elles diffèrent en termes de disponibilité et de coût.

Instances à la demande

Les instances à la demande sont simplement des instances que vous demandez et qui sont crééespour vous. Vous pouvez toujours acquérir une instance à la demande lorsque vous en avez besoin et laconserver aussi longtemps que vous le souhaitez. Les instances à la demande ont un coût fixe ; vousdevez payer pour la durée d'utilisation de ces instances et il n'y a pas d'engagement à long terme.

Instances Spot

Les instances Spot peuvent offrir une alternative très économique aux instances à la demande en tirantparti de la capacité informatique AWS actuellement inutilisée. La disponibilité des instances ponctuellesvarie, ce qui peut les rendre moins chères mais aussi moins viables pour l'hébergement de jeux. Lorsquevous utilisez des instances ponctuelles, il est important de comprendre l'impact de ces caractéristiques.Tout d'abord, les prix au comptant fluctuent en fonction de l'offre et de la demande pour chaque typed'instance dans chaque région. Par conséquent, les instances Spot peuvent être interrompues par AWSavec une notification de deux minutes lorsque AWS a besoin de récupérer de la capacité.

La fonctionnalité GameLift FleetIQ résout ces deux problèmes, rendant l'utilisation des instancesponctuelles viable pour l'hébergement de jeux. Utilisé en combinaison avec une file d'attente, qui contientun groupe de flottes, FleetIQ trouve la meilleure flotte disponible pour accueillir chaque nouvelle sessionde jeu. Lorsqu'une file d'attente possède des flottes ponctuelles, FleetIQ hiérarchise les priorités àl'aide d'instances dont le coût est le plus bas et les chances d'interruption faibles. Par exemple, avecune file d'attente contenant un mélange de flottes ponctuelles T4, C4 et C5, FleetIQ évalue les tauxd'interruption historiques pour chaque type de flotte et ne considère pas les flottes T4 comme non viablespour l'hébergement de jeux. FleetIQ évalue ensuite le coût actuel des instances ponctuelles C4 et C5 etchoisit de placer la session de jeu avec la flotte la moins chère.

Vous pouvez également consulter l'historique de tarification d'un type d'instance dans la console GameLift.La page Historique des instances Spot comporte une représentation graphique de la tarification à lademande et de la tarification Spot et calcule les économies de coût relatives avec les instances Spot.Utilisez les contrôles pour sélectionner un type d'instance, un système d'exploitation, et une plage detemps.

Vous pouvez évaluer les performances de FleetIQ en utilisant un ensemble de métriques de file d'attente,ainsi que les métriques spécifiques à une instance sur les instances Spot. En savoir plus sur les métriquesGameLift (p. 202).

En savoir plus sur la façon d'utiliser les instances Spot dans Utilisation d'instances Spot avecGameLift (p. 115).

Quotas de service d'instance

AWS limite le nombre total d'instances Amazon EC2 (à la demande ou Spot) que vous pouvez avoir dansun compte AWS. En outre, chaque type d'instance a une limite maximale, qui varie selon la région. Vouspouvez demander à étendre ces quotas.

Pour accéder aux informations sur les quotas de service, veuillez consulter :

• Points de terminaison et quotas AWS répertorie les informations générales sur les quotas pour GameLift,ainsi que d'autres services AWS.

Version112

Amazon GameLift Manuel du développeurGuide de conception de flotte

• Recherchez des valeurs de quota spécifiques pour les types d'instance par région dans la consoleGameLift. Accédez à la page Service Limits (Limites de service) et sélectionnez une région pour afficherles quotas concernant les types d'instance disponibles. Cette page affiche également les valeursd'utilisation actuelles pour chaque type d'instance dans la région.

• Récupérez les valeurs de quota pour les types d'instance par région à l'aide de la commande describe-ec2-instance-limits de l'interface de ligne de commande AWS. Cette action retourne également lenombre d'instances actuellement actives dans la région.

Exécution de plusieurs processus sur une flotte GameLiftVous pouvez configurer la configuration d'exécution d'une flotte pour exécuter plusieurs processus parinstance. Selon la façon dont vous configurez votre flotte, l'exécution de plusieurs processus peut vousaider à utiliser vos ressources d'hébergement de manière plus efficace et potentiellement réduire les coûtsd'hébergement globaux.

Comment une flotte gère plusieurs processusGameLift utilise la configuration d'exécution d'une flotte pour déterminer le type et le nombre de processusà exécuter sur chaque instance de la flotte. Au minimum, une configuration d'exécution doit définir uneconfiguration de processus serveur pour spécifier l'exécutable du serveur de jeu. Vous pouvez égalementdéfinir des configurations de processus serveur supplémentaires pour exécuter d'autres types deprocessus liés à votre jeu. Chaque configuration de processus serveur contient les informations suivantes :

• Nom de fichier et chemin d'accès d'un exécutable dans votre build de jeu.• Nombre de processus qui exécutent l'exécutable à gérer simultanément.• (Facultatif) Paramètres à transmettre au processus serveur au lancement.

Lorsqu'une instance de la flotte est lancée, elle démarre immédiatement les processus serveur définis dansla configuration d'exécution. Avec plusieurs processus, chaque démarrage de processus est échelonné dequelques secondes, de sorte que les instances avec de nombreux processus peuvent nécessiter quelquesminutes pour atteindre la pleine capacité. Les processus ont une durée de vie limitée. Au fur et à mesurequ'elles se terminent, les instances démarrent continuellement de nouveaux processus pour maintenir lenombre et le type corrects de processus serveur définis dans la configuration d'exécution actuelle.

Vous pouvez modifier la configuration d'exécution d'une flotte à tout moment en ajoutant, en modifiant ouen supprimant des configurations de processus serveur. Chaque instance vérifie régulièrement les mises àjour de la configuration d'exécution de la flotte, en veillant à ce que les modifications soient mises en œuvrerapidement. Voici comment GameLift adopte les modifications apportées à la configuration d'exécution.

1. Avant qu'une instance vérifie qu'elle exécute le type et le nombre corrects de processus serveur, elledemande d'abord la dernière version de la configuration d'exécution de la flotte au service GameLift.

2. L'instance vérifie ses processus actifs par rapport à la configuration d'exécution actuelle et gère lesécarts comme suit :• Si la configuration d'exécution mise à jour supprime un type de processus serveur : les processus

serveur actifs de ce type continuent à s'exécuter jusqu'à leur fin et ne sont pas remplacés lorsqu'ils seterminent.

• Si la configuration d'exécution mise à jour diminue le nombre de processus simultanés pour un type deprocessus serveur : les processus serveur excédentaires de ce type continuent à s'exécuter jusqu'àleur fin et ne sont pas remplacés lorsqu'ils se terminent.

• Si la configuration d'exécution mise à jour ajoute un nouveau type de processus serveur ou augmenteles processus simultanés pour un type existant : les nouveaux processus serveur sont démarrésimmédiatement, jusqu'au maximum GameLift pour les processus serveur sur une instance. Dans cecas, les nouveaux processus serveur sont lancées uniquement lorsque les processus existants seterminent.

Version113

Amazon GameLift Manuel du développeurGuide de conception de flotte

Optimisation d'une flotte pour plusieurs processus

Au minimum, vous devez effectuer les opérations suivantes pour activer plusieurs processus :

• Créez une build (p. 101) contenant tous les fichiers exécutables de serveur de jeux que voussouhaitez déployer dans une flotte et charger dans GameLift. Tous les serveurs de jeux d'une version degénération doivent s'exécuter sur la même plateforme et être intégrés à GameLift en utilisant le kit SDKGameLift Server pour C++, version 3.0.7 ou ultérieure.

• Créez une configuration d'exécution avec une ou plusieurs configurations de processus serveur etplusieurs processus simultanés.

• Les clients de jeu qui se connectent aux jeux hébergés sur cette flotte doivent être intégrés à l'aide du kitAWS SDK, version 2016-08-04 et suivantes.

En outre, suivez ces recommandations d'intégration de serveurs de jeux pour optimiser les performancesde la flotte :

• Gérez les scénarios d'arrêt des processus serveur afin de veiller à ce que GameLift puisse recycler lesprocessus de manière efficace. Sans ces derniers, les processus serveur ne s'arrêtent que lorsqu'ilséchouent, et les mises à jour de configuration d'exécution peuvent être lentes à implémenter.• Ajoutez une procédure d'arrêt au code de votre serveur de jeu qui appelle l'API serveurProcessEnding().

• Implémentez la fonction de rappel OnProcessTerminate() dans le code de votre serveur de jeuxpour gérer correctement les requêtes de mise hors service depuis GameLift.

• Assurez-vous que les processus serveur malsains sont arrêtés et relancés rapidement. Définissez ceque signifie « sain » et « malsain » pour votre jeu et maintenez l'état de santé de chaque processus.Rapportez ce statut à GameLift en implémentant la fonction de rappel OnHealthCheck() dansle code de votre serveur de jeux. GameLift arrête automatiquement les processus serveur qui sontindiqués comme étant non sains pendant trois minutes consécutives. Si vous n'implémentez pasOnHealthCheck(), GameLift suppose qu'un processus serveur est sain, sauf si le processus neparvient pas à répondre à une communication. Ainsi, les processus serveur peu performants peuventcontinuer d'exister, en utilisant les ressources, jusqu'à ce qu'ils finissent par échouer.

Choix du nombre de processus par instance

Lorsque vous décidez du nombre de processus simultanés à exécuter sur une instance, il y a trois limites àgarder à l'esprit :

• GameLift limite chaque instance à un nombre maximal de processus simultanés. Si votre configurationd'exécution indique une ou plusieurs configurations de processus serveur, la somme de tous lesprocessus simultanés pour les configurations de processus serveur d'une flotte ne peut pas dépassercette limite.

• Le type d'instance Amazon EC2 que vous choisissez peut limiter le nombre de processus qui peuvents'exécuter simultanément, tout en offrant des niveaux de performance acceptables. Vous deveztester différentes configurations de votre jeu pour trouver le nombre optimal de processus pour le typed'instance de votre choix. Certains facteurs peuvent avoir un impact sur votre choix, par exemple lesbesoins en ressources de votre serveur de jeux, le nombre de joueurs à héberger dans chaque sessionde jeu et les attentes en matière de performances des joueurs.

• Lorsque vous modifiez la configuration d'exécution d'une flotte, gardez à l'esprit qu'GameLift n'exécuterajamais un nombre plus élevé de processus simultanés que le nombre total configuré. Cela signifie quela transition entre l'ancienne configuration d'exécution et la nouvelle peut être progressive, les nouveauxprocessus commençant uniquement lorsque les processus existants se terminent. Voici un exemple :votre flotte est configurée pour exécuter 10 processus simultanés de l'exécutable de votre serveur,myGame.exe, avec des paramètres de lancement définis sur « -loglevel=1 ». Vous devez mettre à jour laconfiguration pour continuer à exécuter 10 processus simultanés de myGame.exe, mais vous définissez

Version114

Amazon GameLift Manuel du développeurGuide de conception de flotte

les paramètres de lancement sur « -loglevel=4 ». Étant donné que les instances de la flotte exécutentdéjà 10 processus, chaque instance ne peut pas démarrer un processus avec les nouveaux paramètresde lancement avant qu'un processus avec les anciens paramètres de lancement ne soit terminé.

Utilisation d'instances Spot avec GameLiftLors de la configuration d'un parc de ressources d'hébergement, vous avez la possibilité d'utiliser desinstances Spot, des instances à la demande ou une combinaison. Pour en savoir plus sur la façon dontGameLift utilise les instances Spot, consultez Instances À la demande et Instances Spot (p. 112). Si vouschoisissez d'utiliser des parcs d'instances Spot, vous devrez apporter quelques modifications à l'intégrationde votre jeu.

Vous utilisez FlexMatch pour la mise en relation ? Vous pouvez ajouter des flottes ponctuelles à vos filesd'attente de session de jeu existantes pour les placements de mise en relation.

Pour configurer des ressources d'hébergement et de jeu pour les flottes d'instances Spot :

1. Créez une file d'attente avec une configuration « optimisée pour les instances Spot ». Une bonnepratique consiste à toujours gérer l'utilisation d'une flotte à l'aide d'une file d'attente, mais cela estnécessaire lorsqu'il s'agit d'utiliser des instances Spot. Pour cette étape, vous devrez déterminerles régions à couvrir dans la file d'attente, sélectionner les types d'instance (matériel) appropriéspour votre jeu, et décider comment FleetIQ doit hiérarchiser le placement de session de jeu. En tantque bonne pratique, chaque région de votre file d'attente doit comporter au moins une flotte Spotet une flotte à la demande comme ressource de sauvegarde. Pour une file d'attente avec plusieursflottes Spot, ces flottes doivent utiliser différents types d'instances pour augmenter les chancesd'avoir toujours des flottes Spot viables. Cette conception augmente la résilience de vos ressources.Consultez Conception d'une file d'attente pour les instances Spot (p. 147) pour obtenir de l'aide pourconcevoir une file d'attente optimisée pour les instances Spot.

Dès que vous avez créé les flottes pour votre file d'attente, vous pouvez créer la file d'attente,ajouter les destinations de flotte, puis définir des priorités de flotte. Consultez Création d'une filed'attente (p. 149) pour plus de détails sur la création et la configuration de la nouvelle file d'attente.

2. Créez les flottes pour votre file d'attente optimisée pour les instances Spot. Avant de créer la filed'attente, vous devez créer les flottes qui lui sont destinées. Les flottes d'instances Spot et lesflottes d'instances à la demande peuvent avoir des configurations identiques, avec comme seuledifférence la désignation du type de flotte. Consultez Déployer une flotte GameLift pour une build dejeu personnalisée (p. 116) pour plus de détails sur la création et la configuration de nouvelles flottes.

Note

Nous vous recommandons d'inclure le type de flotte (Spot ou à la demande) dans le nom dela flotte. Ainsi, vous pourrez facilement identifier vos flottes d'instances Spot en un clin d'œildans la liste des noms de flotte, par exemple lors de l'ajout de flottes à une file d'attente.

3. Activez votre client de jeu ou service de client pour placer de nouvelles sessions de jeu à l'aide de lafile d'attente optimisée pour les instances Spot. Si ce n'est déjà fait, mettez à jour votre code client dujeu afin d'utiliser le placement de session de jeu via une file d'attente au lieu de créer des sessions dejeu sur une flotte unique. En utilisant la file d'attente pour placer des sessions de jeu, vous permettezà FleetIQ de sélectionner la meilleure flotte disponible en fonction du coût, du taux d'interruption et dela latence du joueur. Vous fournissez également des ressources d'hébergement de secours au casoù une flotte préférée ne serait temporairement pas disponible. Pour obtenir de l'aide sur la mise enœuvre des placements de sessions de jeu dans votre client de jeu, consultez Création de sessions dejeu (p. 55).

4. Activez votre serveur de jeux pour le traitement d'une interruption Spot. Les instances Spot peuventêtre interrompues avec une notification de deux minutes quand AWS a besoin de récupérer de lacapacité. Vous souhaiterez peut-être que votre serveur de jeux traite correctement une interruption,le cas échéant, et minimise l'impact sur les joueurs. Quand AWS est sur le point de récupérer une

Version115

Amazon GameLift Manuel du développeurDéployer une flotte pour une build de jeu personnalisée

instance Spot, il envoie une notification de résiliation dans les deux minutes qui précèdent, informationtransmise par GameLift à tous les processus serveur concernés. Cette opération est effectuée parl'appel de la fonction de rappel Server SDK onProcessTerminate(). L'implémentation de cettefonction de rappel est toujours une bonne pratique, mais elle est particulièrement importante lorsquevous utilisez des instances Spot. L'implémentation de ce rappel permet de prendre des mesures pourun arrêt sans heurts des sessions de jeu ou la recherche d'un moyen de déplacer les sessions de jeuet joueurs vers un nouveau placement. Consultez Répondre à une notification d’arrêt du processusserveur (p. 49) pour plus de détails sur l'implémentation de onProcessTerminate().

Note

AWS met tout en œuvre pour fournir la notification dès qu'une instance est choisie pour larésiliation, mais il est possible que l'instance Spot soit résiliée avant que l'avertissementn'arrive. Votre serveur de jeu doit être préparé à faire face aux interruptions inattendues.

5. Évaluez les performances de vos flottes d'instances Spot et files d'attente. Dès que la nouvelle filed'attente place de manière active de nouvelles sessions de jeu, utilisez des métriques GameLift pourévaluer les performances. Les métriques clés incluent :

• Taux d'interruption – Suivez le nombre et la fréquence des interruptions Spot pour lesinstances et les sessions de jeu dans une flotte d'instances Spot. Ces métriques de flotte(InstanceInterruptions et GameSessionInterruptions) peuvent être affichées dansla console GameLift ou à l'aide d'Amazon CloudWatch (consultez Métriques GameLift pour lesflottes (p. 202)). Si vous regroupez les métriques de flotte dans un groupe de métriques, vouspouvez aussi afficher les interruptions par type d'instance et de système d'exploitation dansCloudWatch. Les sessions de jeu qui ont été résiliées pour des raisons liées aux instances Spot ontle statut « TERMINATED (RÉSILIÉ) » et le motif de statut « INTERRUPTED (INTERROMPU) ».

• Efficacité de la file d'attente – Suivez les métriques de vos files d'attente, notamment les taux deréussite de placement, le temps d'attente moyen et la profondeur de la file d'attente, afin de vérifierque l'utilisation de flottes d'instances Spot n'a pas d'impact sur les performances de file d'attente.Les métriques de file d'attente peuvent être affichées dans la console GameLift ou à l'aide d'AmazonCloudWatch.

• Utilisation de la flotte – Surveillez les taux d'utilisation de vos flottes, notamment les donnéessur les instances, les sessions de jeu et les sessions de joueur. L'utilisation de vos flottes à lademande peut être un indicateur que FleetIQ choisit d'éviter les placements risqués dans des flottesd'instances Spot et recourt à des flottes à la demande. Les métriques d'utilisation de flotte peuventêtre affichées dans la console GameLift ou à l'aide d'Amazon CloudWatch.

Déployer une flotte GameLift pour une build de jeupersonnaliséeSi vous utilisez des Serveurs en temps réel pour votre jeu, veuillez consulter Déployer une flotte Serveursen temps réel (p. 120).

Vous pouvez créer et déployer une flotte afin d'héberger des serveurs de jeu pour n'importe quelle build dejeu qui a été chargée dans le service GameLift et qui présente le statut Ready (Prêt).

Pour créer une flotte avec une version de jeu personnaliséePour créer une flotte, utilisez la console GameLift ou l'AWS Command Line Interface (interface de ligne decommande).

Une fois que vous avez créé une flotte, le statut de la flotte traverse diverses phases, telles que ledéploiement de la flotte, l'installation des serveurs de jeu et leur démarrage. Une fois que la flotte a atteintle statut ACTIF, elle est prête à héberger des sessions de jeu. Pour obtenir de l'aide face à des problèmesde création de flotte, veuillez consulter Déboguer les incidents de flotte GameLift (p. 127).

Version116

Amazon GameLift Manuel du développeurDéployer une flotte pour une build de jeu personnalisée

Console

1. Ouvrez la console GameLift à l'adresse https://console.aws.amazon.com/gamelift/.2. Sur la page Builds, recherchez la build pour laquelle vous voulez créer une flotte et vérifiez que

son statut est Prêt. Sélectionnez la build (utilisez le bouton d'option situé à gauche du statut de labuild) et cliquez sur Créer une flotte depuis une build.

3. Sur la page Create fleet, entrez les détails Fleet Details :

• Nom – Créez un nom de flotte pertinent afin de pouvoir l'identifier facilement dans une liste etdans les métriques.

• Description – (Facultatif) Ajoutez une courte description de cette flotte pour une meilleureidentification ultérieure.

• Type de flotte – Indiquez si vous souhaitez utiliser des instances à la demande ou des instancesSpot pour cette flotte. En savoir plus sur les types de flotte dans Choisir des ressourcesinformatiques (p. 111).

• Métrique de groupe – (Facultatif) entrez le nom d'un groupe de métriques de flotte nouveauou existant. Lorsque vous utilisez Amazon CloudWatch pour suivre vos métriques GameLift,vous pouvez regrouper les métriques de plusieurs flottes en les ajoutant au même groupe demétriques.

• ARN du rôle d'instance – (Facultatif) Entrez la valeur de l'ARN d'un rôle IAM que vous souhaitezassocier à cette flotte. Ce paramètre permet à toutes les instances de la flotte d'assumer le rôle,ce qui étend l'accès à un ensemble défini de services AWS. Découvrez comment Communiquezavec d’autres ressources AWS de vos flottes (p. 49). Lors de la création d'un parc avec un ARNde rôle dPassRole'instance, vous devez disposer d'une autorisation IAM, comme décrit dansExemples de stratégies IAM pour GameLift (p. 24) .

• Certificate type (Type de certificat) – Choisissez si vous souhaitez qu'GameLift génère uncertificat TLS pour le parc. Vous pouvez utiliser un certificat TLS de flotte pour que votre clientde jeu authentifie un serveur de jeux lors de la connexion, et chiffrer toutes les communicationsclient/serveur. Pour chaque instance d'un parc compatible TLS, GameLift crée aussi unenouvelle entrée DNS avec le certificat. Utilisez ces ressources pour configurer l'authentificationet le chiffrement pour votre jeu. Une fois la flotte créée, vous ne pouvez pas modifier le type decertificat.

• Type binaire – Sélectionnez la « build » de type binaire.• Build – Si vous avez utilisé la fonction Créer une flotte depuis une build, les informations

relatives à la build (nom, ID et système d'exploitation, par exemple) sont automatiquementrenseignées. Dans le cas contraire, sélectionnez une build valide dans la liste déroulante.

4. Type d'instance. Sélectionnez un type d'instance Amazon EC2 dans la liste. Les types d'instancerépertoriés varient en fonction de plusieurs facteurs, comme la région actuelle, le systèmed'exploitation de la build de jeu sélectionnée, ainsi que le type de flotte (à la demande ou Spot). Ensavoir plus sur le choix d'un type d'instance dans Choisir des ressources informatiques (p. 111).Une fois cette flotte créée, vous ne pouvez pas modifier le type d'instance.

5. Gestion de processus. Configurez la manière dont vous voulez que les processus serveurs'exécutent sur chaque instance.

a. Allocation d'un processus serveur :

Spécifiez le type et le nombre de processus serveur de jeux que vous voulez exécuter surchaque instance. Chaque flotte doit avoir au moins une configuration de processus serveurdéfinie, et peut avoir plusieurs configurations. Par exemple, si la build de votre jeu possèdeplusieurs exécutables serveur, vous devez avoir une configuration pour chaque exécutable.

• Chemin de lancement – Saisissez le chemin d'accès à l'exécutable de jeu dans votre build.Tous les chemins de lancement doivent commencer par l'emplacement du serveur de jeux,lequel varie en fonction du système d'exploitation utilisé. Sur les instances Windows, lesserveurs de jeux sont générés dans le chemin C:\game d'accès . Comme sur les instances

Version117

Amazon GameLift Manuel du développeurDéployer une flotte pour une build de jeu personnalisée

Linux, les serveurs de jeux sont générés dans /local/game . Tous les chemins delancement doivent donc commencer par cet emplacement. Exemples : C:\game\MyGame\server.exeou /local/game/MyGame/server.exe .

• Paramètres de lancement – (Facultatif) Vous pouvez transmettre des informations àvotre exécutable de jeu au moment du lancement. Saisissez ici les informations sous laforme d'un ensemble de paramètres de ligne de commande. Exemple: +sv_port 33435+start_lobby.

• Processus simultanés – Indiquez le nombre de processus serveur avec cette configurationà exécuter simultanément sur chaque instance de la flotte. Vérifiez les limites d'GameLiftrelatives au nombre de processus serveur simultanés ; celles-ci dépendent du kit SDKutilisé par votre serveur de jeux.

Une fois que vous avez entré une configuration de processus serveur, cliquez sur la coche decouleur verte pour enregistrer la configuration. Pour ajouter des configurations de processusserveur supplémentaires, cliquez sur Add configuration.

Les limites sur les processus serveur simultanés par instance s'appliquent au nombre total deprocessus simultanés pour toutes les configurations. Si vous êtes limité à un seul processus,vous ne pouvez avoir qu'une seule configuration, et les processus simultanés doivent êtredéfinis sur 1 . Si vous configurez le parc pour qu'il dépasse la limite, il ne peut pas s'activer.

L'ensemble de configurations de processus serveur est appelé configuration d'exécution de laflotte. Il décrit tous les processus serveur qui seront exécutés sur chaque instance dans cetteflotte à un moment donné.

b. Activation des sessions de jeu :

Définissez les limites suivantes pour déterminer comment les nouvelles sessions de jeu sontactivées sur les instances de cette flotte :

• Activation d'une session de jeu simultanée max – Limite le nombre de sessions de jeusur une instance qui peuvent s'activer en même temps. Cette limite est utile lorsquele lancement de plusieurs nouvelles sessions de jeu peuvent avoir un impact sur lesperformances des autres sessions de jeu s'exécutant sur l'instance.

• New activation timeout (Expiration de nouvelle activation) – Ce paramètre limite la duréependant laquelle GameLift autorise l'activation d'une nouvelle session de jeu. Si la sessionde jeu ne termine pas l'activation et n'acquiert pas l'état ACTIVE, l'activation de la sessionde jeu prend fin.

6. Paramètres du port EC2. Cliquez sur Add port settings (Ajouter paramètres du port) afin de définirles autorisations d'accès pour le trafic entrant qui se connecte aux processus serveur déployésau sein de cette flotte. Vous pouvez créer plusieurs paramètres de port pour une flotte. Pourque l'accès soit autorisé, au moins un paramètre de port doit être défini pour la flotte. Si vous nespécifiez pas de paramètres de port à ce moment-là, vous pouvez modifier la flotte ultérieurement.

• Plage de ports – Indiquez une plage de numéros de port que vos serveurs de jeux peuventutiliser pour autoriser des connexions entrantes. Une plage de ports doit utiliser le formatnnnnn[-nnnnn], avec des valeurs comprises entre 1 025 et 60 000. Exemple: 1500ou1500-20000 .

• Protocole – Sélectionnez le type de protocole de communication utilisé par la flotte.• Plage d'adresses IP – Indiquez une plage d'adresses IP valide pour les instances de cette flotte.

Utilisez la notation CIDR. Exemple: 0.0.0.0/0(Cet exemple autorise l'accès à toute personneessayant de se connecter.)

7. Dans la section Protection policy, indiquez si la protection de session de jeu doit ou non êtreappliquée aux instances de cette flotte. Les instances avec protection ne sont pas mises horsservice lors d'un événement de réduction de capacité si elles hébergent une session de jeu active.

Version118

Amazon GameLift Manuel du développeurDéployer une flotte pour une build de jeu personnalisée

Vous pouvez également définir une protection pour des sessions de jeu individuelles. Une fois laflotte créée, vous pouvez la modifier afin de changer sa stratégie de protection.

8. Une fois que vous avez terminé de définir la configuration de votre nouvelle flotte, cliquez surInitialize fleet (Initialiser la flotte). GameLift attribue un ID à la nouvelle flotte et commence leprocessus d'activation de celle-ci. Vous pouvez suivre le statut de la nouvelle flotte sur la pageFlottes.

Vous pouvez mettre à jour les métadonnées et la configuration de la flotte à tout moment, quel quesoit le statut de la flotte (voir Gestion de vos flottes GameLift (p. 124)). Vous pouvez mettre à jour lacapacité de la flotte uniquement une fois que la flotte a atteint le statut ACTIF (voir Dimensionnementde la capacité d'une flotte GameLift (p. 133)).

AWS CLI

Pour créer une flotte avec l'interface AWS CLI, ouvrez une fenêtre de ligne de commande et utilisezla commande create-fleet pour définir une nouvelle flotte. Consultez la documentation complètesur cette commande dans la Référence des commandes d'AWS CLI. Obtenez et installez l'outil AWSCommand Line Interface..

L'exemple create-fleet ci-dessous crée une nouvelle flotte avec les caractéristiques suivantes :

• La flotte utilisera des instances à la demande c5.large avec le système d'exploitation requis pour laversion de build de jeu sélectionnée.

• Elle déploiera la build de serveur de jeux indiquée, qui doit être à l'état Prêt.• La génération de certificats TLS est activée.• Chaque instance de la flotte exécutera dix processus identiques du serveur de jeux simultanément,

en activant chaque instance pour héberger jusqu'à dix sessions de jeu simultanément.• Sur chaque instance, GameLift autorisera uniquement l'activation simultanée de deux nouvelles

sessions de jeu. Elle résiliera également une session de jeu en cours d'activation si elle n'est pasprête à héberger des joueurs dans un délai de 300 secondes.

• La protection de session de jeu sera activée pour toutes les sessions de jeu hébergées sur lesinstances de cette flotte. Elle peut être désactivée pour des sessions de jeu individuelles.

• les joueurs individuels peuvent créer trois nouvelles sessions de jeu au cours d'une période de15 minutes.

• Chaque session de jeu hébergée sur cette flotte disposera d'un point de connexion se trouvant dansles plages d'adresses IP et de ports spécifiées.

• Les métriques de cette flotte seront ajoutées au groupe de EMEAfleets métriques, qui (dans cetexemple) combine les métriques de toutes les flottes des régions EMEA.

$ aws gamelift create-fleet --name "SampleFleet123" --description "The sample test fleet" --ec2-instance-type "c5.large" --fleet-type "ON_DEMAND" --build-id "build-92f061ed-27c9-4a02-b1f4-6f85b2385620" --certificate-configuration "CertificateType=GENERATED" --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"

Version119

Amazon GameLift Manuel du développeurDéployer une flotte Serveurs en temps réel

--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"

Version 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" --certificate-configuration "CertificateType=GENERATED" --ec2-instance-type "c5.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 demande create-fleet aboutit, GameLift renvoie un ensemble d'attributs de flotte comprenant lesparamètres de configuration que vous avez demandés et un nouvel ID de flotte. GameLift démarreimmédiatement le processus d'activation de la flotte et définit le statut de la flotte sur New (Nouveau).Vous pouvez suivre le statut de la flotte et consulter d'autres d'informations de flotte à l'aide de cescommandes d'interface de ligne de commande :

• describe-fleet-events• describe-fleet-attributes• describe-fleet-capacity• describe-fleet-port-settings• describe-fleet-utilization• describe-runtime-configuration

Vous pouvez changer la capacité de la flotte et d'autres paramètres de configuration, si nécessaire, àl'aide des commandes suivantes :

• update-fleet-attributes• update-fleet-capacity• update-fleet-port-settings• update-runtime-configuration

Déployer une flotte Serveurs en temps réelVous pouvez créer une nouvelle flotte de serveurs de jeux RealTime pour héberger des sessions de jeupour votre jeu. Les flottes Serveurs en temps réel demandent la création d'un script RealTime et sonchargement dans Amazon GameLift. Si vous avez une version de serveur de jeux personnalisé, consultezDéployer une flotte GameLift pour une build de jeu personnalisée (p. 116) pour vous aider à créer uneflotte. Pour créer une flotte, utilisez la console Amazon GameLift ou l'AWS Command Line Interface(interface de ligne de commande). Vous pouvez modifier la configuration d'une flotte en modifiant uneflotte (p. 124).

Version120

Amazon GameLift Manuel du développeurDéployer une flotte Serveurs en temps réel

Création d'une flotte Realtime (Console)Pour créer une flotte Realtime avec la console Amazon GameLift :

1. Ouvrez la console Amazon GameLift à l'adresse https://console.aws.amazon.com/gamelift/. Accédezaux flottes : Page Créer une flotte pour configurer une nouvelle flotte.

2. Détails de la flotte.

• Nom – Créez un nom de flotte pertinent afin de pouvoir l'identifier facilement dans une liste et dansles métriques.

• Description – (Facultatif) Ajoutez une courte description de cette flotte pour une meilleureidentification ultérieure.

• Type de flotte – Indiquez si vous souhaitez utiliser des instances à la demande ou des instancesSpot pour cette flotte. En savoir plus sur les types de flotte dans Choisir des ressourcesinformatiques (p. 111).

• Métrique de groupe – (Facultatif) entrez le nom d'un groupe de métriques de flotte nouveau ouexistant. Lorsque vous utilisez Amazon CloudWatch pour suivre vos métriques Amazon GameLift,vous pouvez regrouper les métriques de plusieurs flottes en les ajoutant au même groupe demétriques.

• ARN du rôle d'instance – (Facultatif) Entrez la valeur de l'ARN d'un rôle IAM que vous souhaitezassocier à cette flotte. Ce paramètre permet à toutes les instances de la flotte d'assumer le rôle, cequi étend l'accès à un ensemble défini de services AWS. Découvrez comment Communiquez avecd’autres ressources AWS de vos flottes (p. 49). Lors de la création d'une flotte avec un ARN de rôledPassRole'instance, vous devez disposer d'une autorisation IAM, comme décrit dans Exemples destratégies IAM pour GameLift (p. 24) .

• Certificate type (Type de certifiat) – Choisissez si vous souhaitez qu'GameLift génère un certificatTLS pour le parc. Avec cette fonctionnalité activée pour une flotte en temps réel, GameLiftauthentifie automatiquement la connexion client/serveur et chiffre toutes les communications entre leclient de jeu et le serveur. Une fois la flotte créée, vous ne pouvez pas modifier le type de certificat.

• Type binaire – Sélectionnez le « script » de type binaire.• Script – Sélectionner le script Realtime que vous voulez déployer dans votre menu déroulant.

3. Type d'instance. Sélectionnez un type d'instance Amazon EC2 dans la liste. Les types d'instancerépertoriés varient en fonction de plusieurs facteurs, comme la région actuelle, le systèmed'exploitation de la build de jeu sélectionnée, ainsi que le type de flotte (à la demande ou Spot). Ensavoir plus sur le choix d'un type d'instance dans Choisir des ressources informatiques (p. 111). Unefois cette flotte créée, vous ne pouvez pas modifier le type d'instance.

4. Gestion de processus. Configurez la manière dont vous voulez que les processus serveur s'exécutentsur chaque instance.

a. Allocation d'un processus serveur.

Spécifiez le type et le nombre de processus serveur de jeux que vous voulez exécuter sur chaqueinstance. Chaque flotte doit avoir au moins une configuration de processus serveur définie, etpeut avoir plusieurs configurations. Par exemple, si vous souhaitez lancer des processus utilisantplusieurs fichiers dans votre script Realtime chargé, vous devez disposer d'une configuration pourchaque type de processus que vous souhaitez lancer.

• Chemin de lancement – Tapez le nom du fichier de script que vous souhaitez lancer avec.Un fichier de script de lancement doit appeler une fonction Init(). Pendant le déploiement,vos fichiers scripts Realtime chargés sont décompressés et stockés dans le répertoire /local/game/. Par conséquent, il vous suffit de spécifier le nom du fichier de script. Exemple:MyRealtimeLaunchScript.js.

• Paramètres de lancement – (Facultatif) Vous pouvez transmettre des informations à votre scriptRealtime au moment du lancement. Saisissez les informations sous la forme d'un ensemble deparamètres de ligne de commande. Exemple: +map Winter444.

Version121

Amazon GameLift Manuel du développeurDéployer une flotte Serveurs en temps réel

• Processus simultanés – Indiquez le nombre de processus serveur avec cette configuration àexécuter simultanément sur chaque instance de la flotte.

Une fois que vous avez entré une configuration de processus serveur, cliquez sur la coche decouleur verte sur la droite pour enregistrer la configuration. Pour ajouter des configurations deprocessus serveur supplémentaires, cliquez sur Add configuration.

Vérifiez les limites d'Amazon GameLift https://aws.amazon.com//ec2/faqs/#Is_Amazon_EC2_used_in_conjunction_with_Amazon_S3 concernant le nombre de processusserveur simultanés. Les limites sur les processus serveur simultanés par instance s'appliquent aunombre total de processus simultanés défini pour toutes les configurations. Par exemple, si vousêtes limité à un seul processus, vous ne pouvez avoir qu'une seule configuration, et les processussimultanés doivent être définis sur 1 . Si un parc est configuré pour dépasser la limite, il ne peutpas s'activer.

L'ensemble de configurations de processus serveur est appelé configuration d'exécution de laflotte. Il décrit tous les processus serveur qui seront exécutés sur chaque instance dans cette flotteà un moment donné.

b. Activation des sessions de jeu (facultatif) :

Définissez les limites suivantes pour déterminer comment les nouvelles sessions de jeu sontactivées sur les instances de cette flotte :

• Activation d'une session de jeu simultanée max – Limite le nombre de sessions de jeu sur uneinstance qui peuvent s'activer en même temps. Cette limite est utile lorsque le lancement deplusieurs nouvelles sessions de jeu peuvent avoir un impact sur les performances des autressessions de jeu s'exécutant sur l'instance.

• Expiration de nouvelle activation – Ce paramètre limite la durée pendant laquelle AmazonGameLift autorise l'activation d'une nouvelle session de jeu. Si la session de jeu n'acquiert pasl'état ACTIVE, le processus d'activation de la session de jeu prend fin.

5. Stratégie de protection (facultatif). Indiquez si la protection de session de jeu doit ou non êtreappliquée aux instances de cette flotte. Les instances protégées ne sont pas mises hors service lorsd'un événement de réduction de capacité si elles hébergent une session de jeu active. L'utilisation deces paramètres applique une stratégie de protection à l'échelle de la flotte. Vous pouvez égalementdéfinir une protection pour des sessions de jeu individuelles lors de la création de la session de jeu.

6. Une fois que vous avez terminé la configuration de votre nouvelle flotte, cliquez sur Initialiser la flotte.Amazon GameLift attribue un ID à la nouvelle flotte et commence le processus d'activation de celle-ci. Vous pouvez consulter l'état de la nouvelle flotte sur la page Fleets. Une fois que la flotte estactive, vous pouvez modifier sa capacité (p. 135), la configuration d'exécution, ainsi que d'autresparamètres de configuration si nécessaire.

Création d'une flotte Realtime (AWS CLI)Pour créer une flotte Realtime avec l'interface AWS CLI, ouvrez une fenêtre de ligne de commandeet utilisez la commande create-fleet pour définir une nouvelle flotte. Consultez la documentationcomplète sur cette commande dans la Référence des commandes d'AWS CLI. Obtenez et installez l'outilAWS Command Line Interface..

L'exemple create-fleet ci-dessous crée une nouvelle flotte avec les caractéristiques suivantes :

• La flotte utilisera des instances Spot c5.large.• Elle déploiera le script Realtime spécifié.• Chaque instance de la flotte exécutera dix processus identiques du script Realtime simultanément, en

activant chaque instance pour héberger jusqu'à dix sessions de jeu simultanément.

Version122

Amazon GameLift Manuel du développeurDéployer une flotte Serveurs en temps réel

• Sur chaque instance, Amazon GameLift autorisera uniquement l'activation simultanée de deux nouvellessessions de jeu. Elle résiliera également une session de jeu en cours d'activation si elle n'est pas prête àhéberger des joueurs dans un délai de 60 secondes.

• La protection de session de jeu sera activée pour toutes les sessions de jeu hébergées sur les instancesde cette flotte. Elle peut être désactivée pour des sessions de jeu individuelles.

• les joueurs individuels peuvent créer trois nouvelles sessions de jeu au cours d'une période de15 minutes.

• Les métriques de cette flotte seront ajoutées au groupe de EMEAfleets métriques, qui (dans cetexemple) combine les métriques de toutes les flottes des régions EMEA.

Note

Pour les flottes des serveurs en temps réel, Amazon définit GameLift automatiquement lesplages TCP et UDP à utiliser par les serveurs en temps réel. Vous pouvez afficher les paramètresautomatiques en appelant la commande de l'interface de ligne de commande describe-fleet-port-settings.

$ aws gamelift create-fleet --name "SampleRealtimeFleet123" --description "A sample Realtime fleet" --ec2-instance-type "c5.large" --fleet-type "SPOT" --script-id "script-1111aaaa-22bb-33cc-44dd-5555eeee66ff" --certificate-configuration "CertificateType=GENERATED" --runtime-configuration "GameSessionActivationTimeoutSeconds=60, MaxConcurrentGameSessionActivations=2, ServerProcesses=[{LaunchPath=/local/game/myRealtimeLaunchScript.js, Parameters=+map Winter444, ConcurrentExecutions=10}]" --new-game-session-protection-policy "FullProtection" --resource-creation-limit-policy "NewGameSessionsPerCreator=3, PolicyPeriodInMinutes=15" --MetricGroups "EMEAfleets"

Version copiable :

aws gamelift create-fleet --name "SampleRealtimeFleet123" --description "A sample Realtime fleet" --ec2-instance-type "c5.large" --fleet-type "SPOT" --script-id "script-1111aaaa-22bb-33cc-44dd-5555eeee66ff" --certificate-configuration "CertificateType=GENERATED" --runtime-configuration "GameSessionActivationTimeoutSeconds=60,MaxConcurrentGameSessionActivations=2,ServerProcesses=[{LaunchPath=/local/game/myRealtimeLaunchScript.js,Parameters=+map Winter444,ConcurrentExecutions=10}]" --new-game-session-protection-policy "FullProtection" --resource-creation-limit-policy "NewGameSessionsPerCreator=3,PolicyPeriodInMinutes=15" --MetricGroups "EMEAfleets"

Si la demande create-fleet aboutit, Amazon GameLift renvoie un ensemble d'attributs de flotte comprenantles paramètres de configuration que vous avez demandés et un nouvel ID de flotte. Amazon GameLiftdémarre immédiatement le processus d'activation de la flotte et définit le statut de la flotte sur New(Nouveau). Vous pouvez suivre le statut de la flotte et consulter d'autres d'informations de flotte à l'aide deces commandes d'interface de ligne de commande :

• describe-fleet-events• describe-fleet-attributes• describe-fleet-capacity• describe-fleet-port-settings

Version123

Amazon GameLift Manuel du développeurGestion de vos flottes

• describe-fleet-utilization• describe-runtime-configuration

Une fois que la flotte est active, vous pouvez changer la capacité de la flotte et d'autres paramètres deconfiguration si nécessaire à l'aide de ces commandes :

• update-fleet-attributes• update-fleet-capacity• update-fleet-port-settings• update-runtime-configuration

Gestion de vos flottes GameLiftUtilisez la console GameLift ou l'interface de ligne de commande AWS pour gérer vos flottes existantes,(et pour mettre à jour les attributs, les paramètres de port et de configuration d'exécution de la flotte). Vouspouvez également supprimer une flotte.

Pour mettre à jour une configuration de flotteUtilisez la page Edit fleet (Modifier la flotte) de la console GameLift pour modifier la configuration d'uneflotte. Toutes les propriétés d'une flotte peuvent être modifiées à l'exception de l'ID build et du typed'instance. Pour modifier les paramètres de dimensionnement, consultez Dimensionner automatiquementla capacité de la flotte avec GameLift (p. 137).

Note

Une flotte active peut être déployée avec une build qui a été supprimée ou est en état d'erreur.Cela n'affecte pas le statut de la flotte ni sa capacité à héberger des sessions de jeu. Dans ce cas,vous pouvez voir un statut de build Deleted (Supprimée) ou Error (si une erreur s'est produite lorsd'une tentative de récupération des informations de la build).

GameLift Console

1. Ouvrez la console Amazon GameLift à l'adresse https://console.aws.amazon.com/gamelift/.2. Choisissez Fleets dans la barre de menus pour afficher une liste des flottes et cliquez sur le nom

de la flotte que vous souhaitez mettre à jour. Une flotte doit se trouver dans l'état ACTIVE avant depouvoir être modifiée.

3. Sur la page Fleet detail (Informations sur la flotte), sous Actions, choisissez Edit fleet (Modifier laflotte).

4. Sur la page Edit fleet, vous pouvez effectuer les mises à jour suivantes (consultez Déployer uneflotte GameLift pour une build de jeu personnalisée (p. 116) pour plus des descriptions dechamp plus détaillées) :

• Modifiez les attributs de la flotte tels que Name et Description.• Ajoutez ou supprimez des Metric groups (groupes de métriques) utilisés dans Amazon

CloudWatch pour suivre les métriques GameLift agrégées de plusieurs flottes.• Modifiez la façon dont vous souhaitez que les processus serveur s'exécutent et hébergent des

sessions de jeu en mettant à jour Server process allocation (Allocation des processus serveur)(configuration d'exécution) et les paramètres d'activation de session de jeu.

• Mettez à jour EC2 port settings (Paramètres de port EC2) utilisés pour se connecter à desprocessus serveur de cette flotte.

• Mettez à jour les paramètres de limite de création des ressources.

Version124

Amazon GameLift Manuel du développeurGestion de vos flottes

• Activez ou désactivez la protection des sessions de jeu.5. Cliquez sur Submit (Soumettre) pour enregistrer vos changements.

AWS CLI

Utilisez les commandes suivantes de l'interface de ligne de commande AWS pour mettre à jour uneflotte :

• update-fleet-attributes• update-fleet-port-settings• update-runtime-configuration

Pour supprimer une flotteLorsque vous n'avez plus besoin d'une flotte, vous pouvez la supprimer. La suppression définitive d'uneflotte supprime toutes les données associées aux sessions de jeu et aux sessions de joueur, ainsi queles données des métriques collectées. Comme alternative, vous pouvez conserver la flotte, désactiver lascalabilité automatique et mettre à l'échelle manuellement la flotte à 0 instance.

Note

Si la flotte en cours de suppression dispose d'une connexion d'appairage de VPC, vous devezd'abord demander l'autorisation en appelant CreateVpcPeeringAuthorization. Vous n'avez pasbesoin de supprimer explicitement la connexion d'appairage de VPC, cette opération s'effectuedans le cadre du processus de suppression de la flotte.

Vous pouvez utiliser la console Amazon GameLift ou l'outil d'interface de ligne de commande AWS poursupprimer une flotte.

GameLift Console

1. Ouvrez la console Amazon GameLift à l'adresse https://console.aws.amazon.com/gamelift/.2. Choisissez Fleets dans la barre de menus pour afficher une liste des flottes et cliquez sur le nom

de la flotte que vous souhaitez supprimer. Seules les flottes ayant le statut ACTIF ou ERREURpeuvent être supprimées.

3. Dans la page de détails Flotte de votre flotte sélectionnée, vérifiez que la flotte dispose de zéroinstance active. Si la flotte possède encore des instances, accédez à l'onglet Dimensionnement etprocédez comme suit :

• Cochez la case Disable all scaling policies for the fleet (Désactiver toutes les stratégies de miseà l'échelle pour la flotte). Cette action arrête toute scalabilité automatique, qui pourrait contrervos paramètres de mise à l'échelle manuelle.

• Ajustez manuellement le nombre d'instances souhaité à « 0 ».

La réduction de la capacité de la flotte peut prendre plusieurs minutes. Si des instancesquelconques ont des sessions de jeu actives avec protection de session de jeu, vous devezattendre que les sessions de jeu se terminent ou arrêter la protection des sessions de jeu actives(cela ne peut pas être effectué dans la console, consultez UpdateGameSession).

4. Une fois que la flotte a été réduite à zéro instance active, vous pouvez supprimer la flotte. En hautde la page de détails Flotte, sous Actions, choisissez Résilier la flotte.

5. Dans la boîte de dialogue Terminate fleet, confirmez la suppression en saisissant le nom de laflotte.

6. Cliquez sur Delete.

Version125

Amazon GameLift Manuel du développeurAjouter un alias à une flotte

AWS CLI

Obtenez et installez l'outil AWS Command Line Interface.

1. Dans une fenêtre de ligne de commande, appelez describe-fleet-capacity et vérifiez que la flotte àsupprimer a été réduite à zéro instance active. Si la flotte dispose encore d'instances actives :

a. appelez stop-fleet-actions pour désactiver la scalabilité automatique.b. Appelez update-fleet-capacity et définissez le paramètre desired-instances à « 0 ».c. Attendez que la flotte soit réduite à zéro instance active. Cela peut prendre plusieurs minutes.

Si des instances quelconques ont des sessions de jeu actives avec protection de session dejeu, vous devez attendre que les sessions de jeu se terminent ou arrêter la protection dessessions de jeu actives (voir update-game-session).

2. Une fois que la flotte a été réduite, appelez delete-fleet pour supprimer la flotte.

Ajouter un alias à une flotte GameLifta GameLift alias est utilisé pour extraire une désignation de flotte. Les désignations de flotte indiquent àAmazon GameLift où rechercher des ressources disponibles lors de la création de sessions de jeu pour lesjoueurs. En utilisant des alias au lieu d'ID de flotte spécifiques, vous pouvez plus facilement et de manièretransparente faire passer le trafic de joueurs d'une flotte à une autre en modifiant l'emplacement cible del'alias.

Il existe deux types de stratégies de routage pour les alias :

• Simple – Un alias simple achemine le trafic de joueurs vers un ID de flotte spécifié. Vous pouvez mettre àjour l'ID de flotte d'un alias à tout moment.

• Terminal – Une flotte ne peut pas être résolue par un alias de terminal. Au lieu de cela, l'alias retransmetun message au client. Par exemple, il est possible que vous souhaitiez diriger les joueurs qui utilisent unclient obsolète vers un emplacement où ils peuvent obtenir une mise à niveau.

Les flottes ont une durée de vie limitée et plusieurs raisons vous amèneront à changer de flottes au coursde la vie d'un jeu. Plus précisément, vous ne pouvez pas mettre à jour la version du serveur de jeux d'uneflotte ni modifier certains attributs de ressource de calcul (types d'instances, spot/à la demande) d'uneflotte existante. Au lieu de cela, vous devez créer d'autres flottes avec les modifications, puis basculer lesjoueurs vers les nouvelles flottes. Avec des alias, le changement de flottes a un impact minimal sur votrejeu et est invisible pour les joueurs.

Les alias sont surtout pratiques dans des jeux qui n'utilisent pas de files d'attente. Pour changer deflottes dans une file d'attente, il suffit de créer une nouvelle, de l'ajouter à la file d'attente et de supprimerl'ancienne flotte, aucune de ces opérations n'étant visible pour les joueurs. Par opposition, les clients dejeu qui n'utilisent pas de files d'attente doivent spécifier la flotte à utiliser lors de la communication avec leservice GameLift. Sans alias, un changement de flotte nécessite des mises à jour du code de votre jeu et,éventuellement, la nécessité de distribuer des clients de jeu mis à jour aux joueurs. Avec un alias, vouspouvez éviter les deux.

Pour créer un aliasVous pouvez créer un alias à l'aide de la console GameLift, comme décrit ici, ou à l'aide de la commandecreate-alias de l'interface de ligne de commande AWS.

1. Ouvrez la console Amazon GameLift à l'adresse https://console.aws.amazon.com/gamelift/.2. Choisissez Alias dans la barre de menu.3. Sur la page Aliases, cliquez sur Create alias.4. Sur la page Create alias, dans la section Alias details, procédez comme suit :

Version126

Amazon GameLift Manuel du développeurDéboguer les incidents de flotte

• Nom d'alias – Saisissez un nom convivial afin d'identifier facilement l'alias dans le catalogue.• Description – (Facultatif) Saisissez une courte description pour votre alias afin d'ajouter une

identification supplémentaire.5. Dans la section Routing options, en regard de Type, choisissez Simple ou Terminal :

• Si vous choisissez Simple, sélectionnez une flotte disponible à associer à votre alias. Un alias simpleachemine le trafic de joueurs vers la flotte associée.

• Si vous sélectionnez Terminal, saisissez un message qui sera affiché pour les joueurs. Un alias determinal ne se résout pas en une flotte mais transmet seulement votre message au client.

6. Cliquez sur Configure alias.

Pour modifier un aliasVous pouvez modifier un alias à l'aide de la console GameLift, comme décrit ici, ou à l'aide de lacommande AWS CLI update-alias.

1. Ouvrez la console Amazon GameLift à l'adresse https://console.aws.amazon.com/gamelift/.2. Choisissez Alias dans la barre de menu.3. Sur la page Alias, cliquez sur le nom de l'alias que vous voulez modifier.4. Sur la page de l'alias sélectionné, en regard de Actions, choisissez Éditer un alias.5. Sur la page Éditer un alias, vous pouvez modifier les éléments suivants :

• Nom d'alias – Nom convivial de votre alias.• Description – Courte description de votre alias.• Type – Stratégie de routage pour le trafic de joueurs. Sélectionnez Simple pour changer la flotte

associée ou sélectionnez Terminal pour modifier le message de fin.6. Cliquez sur Soumettre.

Déboguer les incidents de flotte GameLiftCette rubrique fournit des conseils sur les problèmes de configuration de flotte pour une solution GameLiftgérée. Pour un dépannage supplémentaire, vous pouvez accéder à distance à une instance de flotte unefois que la flotte est active. Voir Accès à distance aux instances de flotte GameLift (p. 130).

Problèmes de création de flotteFonctionnement de la création d'une flotte

Lorsque vous créez une flotte, le service GameLift effectue une série de tâches pour préparer une instanceunique selon la configuration de la flotte. Tandis que chaque phase de création de la flotte se termine,une série d'événements est émise pour la flotte ainsi que l'état actuel de la flotte. Vous pouvez suivre tousles événements, y compris ceux de la création de la flotte, à l'aide de la console GameLift (voir la pagedétaillée sur la flotte, sous l'onglet Événements).

Les problèmes à la création d'une flotte mettent la flotte en état d'l'Error (Erreur), accompagné d'unmessage d'erreur descriptif. La phase dans laquelle la création de la flotte a échoué peut également être unbon indicateur. Les phases de création d'une flotte sont les suivantes :

• Nouveau – L'enregistrement de flotte est créé. Les ressources sont allouées pour la première instance.• Téléchargement en cours – Les fichiers de la build de jeu sont téléchargés sur l'instance, puis extraits.• Validation en cours – Les fichiers de la build de jeu téléchargés sont validés.

Version127

Amazon GameLift Manuel du développeurDéboguer les incidents de flotte

• Création – La build de serveur de jeux est installée sur l'instance, à l'aide d'un script d'installation, sidisponible.

• Activation – En fonction de la configuration d'exécution de la flotte, des processus serveur sont démarrés.Au moins un processus doit communiquer avec GameLift pour signaler lorsqu'il est prêt à héberger unesession de jeu.

Dès qu'un processus serveur indique à GameLift qu'il est prêt, la flotte passe au statut Actif.

Problèmes courantsTéléchargement et validation

Au cours de cette phase, la création de la flotte peut échouer s'il existe des problèmes liés aux fichiers debuild extraits, si le script d'installation ne s'exécute pas ou si les exécutables désignés dans la configurationd'exécution ne sont pas inclus dans les fichiers de build. GameLift fournit les journaux relatifs à chacun deces problèmes.

Si les entrées n'affichent aucun problème, il est possible que le problème soit dû à une erreur de serviceinterne. Si c'est le cas, réessayez de créer la flotte. Si le problème persiste, envisagez de recharger labuild de jeu (dans le cas où les fichiers ont été corrompues). Vous pouvez également contacter le supportGameLift ou poser une question sur le forum.

Création

Les problèmes qui provoquent l'échec lors de la phase de génération sont en général toujours dû auxfichiers de la build du jeu et/ou au script d'installation. Vérifiez que vos fichiers de la build du jeu, chargésdans GameLift, peuvent être installés sur un ordinateur exécutant un système d'exploitation adapté. Veillezà utiliser une installation de système d'exploitation, et non un environnement de développement existant.

Activation

Les problèmes les plus courants de création de flotte surviennent lors de la phase d'activation. Au cours decette phase, un certain nombre d'éléments sont testés, dont la viabilité du serveur de jeu, les paramètresde configuration d'exécution et la capacité du serveur de jeu à interagir avec le service GameLift en utilisantle kit SDK Server. Problèmes courants pouvant survenir lors de l'activation de la flotte :

Les processus serveur ne parviennent pas à démarrer.

Vérifiez d'abord que vous avez correctement défini le chemin de lancement et les paramètresde lancement facultatifs dans la configuration d'exécution de la flotte. Vous pouvez consulter laconfiguration d'exécution actuelle de la flotte à l'aide de la console GameLift (voir la page Détails de laflotte, Allocation de capacité (p. 199)) ou en appelant la commande describe-runtime-configurationde l'AWS CLI. Si la configuration d'exécution semble correcte, vérifiez s'il y a des problèmes avec vosfichiers de la build du jeu et/ou le script d'installation.

Les processus serveur démarrent mais la flotte ne parvient pas à s'activer.

Si les processus serveur démarrent et continuent à s'exécuter avec succès, mais que la flotte nepasse pas au statut Actif, cela peut être dû au fait que le processus serveur ne parvient pas à indiquerà GameLift qu'il est prêt à héberger des sessions de jeu. Vérifiez que votre serveur de jeux appellecorrectement l'action d'API Server ProcessReady() (voir Initialiser le processus serveur (p. 46)).

La demande de connexion d'appairage de VPC a échoué.

Pour les flottes créées avec une connexion d'appairage de VPC (voir Pour configurer l'appairage deVPC avec une nouvelle flotte (p. 189)), l'appairage de VPC est effectué au cours de cette phased'activation. Si un appairage de VPC échoue pour une raison quelconque, la nouvelle flotte n'obtiendrapas le statut Actif. Vous pouvez suivre la réussite ou l'échec de la demande d'appairage en appelantdescribe-vpc-peering-connections. Veillez à vérifier qu'une autorisation d'appairage de VPC valideexiste (describe-vpc-peering-authorizations), car les autorisations ne sont valides que 24 heures.

Version128

Amazon GameLift Manuel du développeurDéboguer les incidents de flotte

Problèmes liés aux processus serveurLes processus serveur démarrent mais échouent rapidement ou indiquent une intégrité médiocre.

Hormis les problèmes liés à votre version de génération de jeu, cela peut se produire lorsque vousessayez d'exécuter trop de processus serveur simultanément sur l'instance. Le nombre optimal deprocessus simultanés dépend des exigences relatives au type d'instance et aux ressources de votreserveur de jeux. Essayez de réduire le nombre de processus simultanés, lequel est défini dans laconfiguration d'exécution de la flotte, pour voir si les performances s'améliorent. Vous pouvez modifierla configuration d'exécution d'une flotte à l'aide de la console GameLift (modifiez les paramètresd'allocation de capacité de la flotte) ou en appelant la commande update-runtime-configuration del'AWS CLI.

Problèmes de suppression de flotteUne flotte ne peut pas être résiliée en raison d'un nombre d'instances maximum.

Le message d'erreur indique que la flotte en cours de suppression dispose encore d'instances actives,ce qui n'est pas autorisé. Vous devez d'abord mettre à l'échelle une flotte en la réduisant à zéroinstance active. Cela s'effectue en définissant manuellement le nombre d'instances souhaitées dela flotte à « 0 », puis en attendant que la réduction prenne effet. Veillez à désactiver la scalabilitéautomatique, qui contrecarrera les paramètres manuels.

Les actions de VPC ne sont pas autorisées.

Ce problème s'applique uniquement aux flottes pour lesquelles vous avez créé spécifiquement desconnexions d'appairage de VPC (voir Homologation VPC pour GameLift (p. 187)). Ce scénariose produit parce que le processus de suppression d'une flotte inclut également la suppressiondes connexions d'appairage du VPC de la flotte et de tout VPC. Vous devez d'abord obtenir uneautorisation en appelant l'API de service GameLift CreateVpcPeeringAuthorization() ou en utilisant lacommande create-vpc-peering-authorization de l'interface de ligne de commande AWS. Unefois que vous avez l'autorisation, vous pouvez supprimer la flotte.

Problèmes de flotte Serveurs en temps réelSessions de jeu zombie : elles commencent à exécuter un jeu, mais ne se terminent jamais.

Vous pouvez observer ces problèmes dans les scénarios suivants :• Les mises à jour des scripts ne sont pas collectées par les serveurs RealTime de la flotte.• La flotte atteint rapidement sa capacité maximale et n'est pas réduite lorsque l'activité des joueurs

(telle que les nouvelles demandes de session de jeu) diminue.

Ceci découle de façon quasi-certaine d'un échec de l'appel à processEnding dans votre scriptRealTime. La flotte est activée et les sessions de jeu démarrées, mais il n'y a pas de méthode pourles arrêter. Par conséquent, le serveur RealTime qui exécute la session de jeu n'est jamais libérépour en démarrer une nouvelle, et de nouvelles sessions de jeu ne peuvent démarrer que lorsque denouveaux serveurs RealTime sont activés. En outre, les mises à jour du script RealTime n'affectentpas les sessions de jeu déjà en cours d'exécution, mais seulement les nouvelles.

Pour éviter que cela se produise, les scripts doivent fournir un mécanisme pour déclencher un appelprocessEnding. Comme illustré dans Exemple de script de Serveurs en temps réel (p. 74), unesolution consiste à programmer un délai d'expiration de session inactive, tel que si aucun joueur n'estconnecté pendant un certain temps, le script met un terme à la session de jeu actuelle.

Toutefois, si vous suivez ce scénario, quelques solutions de contournement vous permettent dedébloquer vos serveurs RealTime. L'astuce consiste à déclencher les processus serveur RealTime (ou

Version129

Amazon GameLift Manuel du développeurAccès à distance aux instances de flotte

les instances de flotte sous-jacentes) pour redémarrer. Dans ce cas, GameLift ferme automatiquementles sessions de jeu pour vous. Une fois que les serveurs RealTime sont libérés, ils peuvent démarrerde nouvelles sessions de jeu à l'aide de la dernière version du script RealTime.

Il existe deux méthodes pour y parvenir, en fonction de l'ampleur du problème :• Mettre à l'échelle la totalité de la flotte en la réduisant. Cette méthode est la plus simple à mettre en

œuvre mais a un effet étendu. Mettez à l'échelle la flotte en la réduisant à zéro instance, attendez laréduction complète de la flotte, puis remettez-la à l'échelle en l'augmentant. Cela permet d'effacertoutes les sessions de jeu existantes et vous permet de repartir à zéro avec le script RealTime mis àjour le plus récemment.

• Accéder à distance à l'instance et redémarrer le processus. Il s'agit d'une bonne option si vousn'avez que quelques processus à corriger. Si vous êtes déjà connecté à l'instance, par exempleaux journaux de processus ou de débogage, cette méthode peut être la plus rapide. Voir Accès àdistance aux instances de flotte GameLift (p. 130).

Si vous choisissez de ne pas inclure de manière d'appeler processEnding dans votre script RealTime, ilexiste quelques situations épineuses qui peuvent se produire, même lorsque la flotte devient active et queles sessions de jeu sont démarrées. Tout d'abord, une session de jeu en cours d'exécution ne se terminepas. Par conséquent, le processus serveur qui exécute cette session de jeu n'est jamais libre de démarrerune nouvelle session de jeu. Deuxièmement, le serveur RealTime ne collecte aucune mise à jour de script.

Accès à distance aux instances de flotte GameLiftVous pouvez accéder à distance à n’importe quelle instance de parc en cours d’exécution dans unGameLift flotte. Cette fonctionnalité est utile pour le dépannage des problèmes d'activation de flotte. Vouspouvez également utiliser cette fonctionnalité pour connaître l'activité en temps réel du serveur de jeux,comme les mises à jour des journaux de suivi, ou exécuter des outils de comparaison à partir du trafic dejoueurs actuel.

Lors de l'accès à distance aux instances GameLift individuelles, gardez ce qui suit à l'esprit :

• Le service GameLift continue de gérer l'activité et la capacité de la flotte. L'établissement d'uneconnexion à distance à une instance n'a pas d'incidence sur la façon dont GameLift la gère. Parconséquent, l'instance continue à exécuter la configuration d'exécution de la flotte, à arrêter et démarrerles processus serveur, à créer et résilier des sessions de jeu et à autoriser les connexions de joueur.En outre, le service GameLift peut mettre hors service l'instance à tout moment dans le cadre d'unévénement de réduction de capacité.

• L'apport de modifications locales à une instance qui héberge des sessions de jeu actives et comportedes joueurs connectés en direct peut avoir une incidence significative sur l'expérience des joueurs. Parexemple, vos modifications locales pourraient déconnecter des joueurs individuels, bloquer des sessionsde jeu ou encore arrêter l'intégralité d'une instance avec plusieurs sessions de jeu et joueurs concernés.

Pour plus d'informations sur la façon dont les jeux sont déployés et gérés sur des instances GameLift,consultez les rubriques suivantes :

• Fonctionnement d'un Amazon GameLift (p. 3)• Déboguer les incidents de flotte GameLift (p. 127)• Comment une flotte gère plusieurs processus (p. 113)

Connexion à une instanceVous pouvez accéder à des instances à distance qui exécutent Windows ou Linux. Pour vous connecterà une instance Windows, utilisez un client RDP (Remote Desktop Protocol). Pour vous connecter à uneinstance Linux, utilisez un client SSH.

Version130

Amazon GameLift Manuel du développeurAccès à distance aux instances de flotte

Utilisez l'interface AWS CLI pour obtenir les informations dont vous avez besoin pour accéder à uneinstance à distance. Pour obtenir de l’aide, consultez le AWS CLI Référence de la commande. Obtenezet installez l'outil AWS Command Line Interface. Vous pouvez également utiliser le kit SDK AWS, avec ladocumentation disponible dans les Références API du service GameLift.

1. Recherchez l'ID de l'instance à laquelle vous souhaitez vous connecter. Lorsque vous demandezun accès, vous devez spécifier un ID d'instance. Utilisez la commande de l'interface de ligne decommande AWS describe-instances (ou l'appel d'API DescribeInstances) avec un ID de flotte pourobtenir des informations sur toutes les instances de la flotte. Pour obtenir de l'aide, ainsi que desexemple de requêtes et de réponses, consultez les guides sur les références API ou CLI.

2. Demandez des informations d'identification d'accès pour l'instance. Une fois que vous avez un IDd'instance, utilisez la commande get-instance-access (ou l'appel d'API GetInstanceAccess) pourdemander des informations d'identification d'accès et d'autres informations. Pour obtenir de l'aide, ainsique des exemple de requêtes et de réponses, consultez les guides sur les références API ou CLI. Encas de succès, GameLift renvoie le système d'exploitation et l'adresse IP de l'instance, ainsi qu'unensemble d'informations d'identification (nom d'utilisateur et clé secrète). Le format des informationsd'identification dépend du système d'exploitation de l'instance. Utilisez les instructions suivantesextraire les informations d'identification pour RDP ou SSH.

• Pour les instances Windows – Pour la connexion à une instance Windows, RDP a besoin d'unnom d'utilisateur et d'un mot de passe. La demande get-instance-access renvoie ces valeurssous la forme de chaînes simples, afin que vous puissiez les valeurs telles quelles. Exempled'informations d'identification :

"Credentials": { "Secret": "aA1bBB2cCCd3EEE", "UserName": "gl-user-remote"}

• Pour les instances Linux – Pour la connexion à une instance Linux, SSH a besoin d'un nomd'utilisateur et d'une clé privée. GameLift émet des clés privées RSA et les retourne sous la formed'une chaîne unique, avec le caractère de nouvelle ligne (\n) pour indiquer les sauts de ligne. Pourrendre la clé privée utilisable, vous devez (1) convertir la chaîne en un fichier .pem et (2) définir desautorisations pour le nouveau fichier. Exemple d'informations d'identification renvoyées :

"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-----",

Version131

Amazon GameLift Manuel du développeurAccès à distance aux instances de flotte

"UserName": "gl-user-remote"}

Lorsque vous utilisez l'interface de ligne de commande AWS, vous pouvez générerautomatiquement un fichier .pem correctement formaté en incluant les paramètres --query et --output à votre requête get-instance-access.

Pour définir des autorisations sur le fichier .pem, exécutez la commande suivante :

$ chmod 400 MyPrivateKey.pem

3. Ouvrez un port pour la connexion à distance. Les instances des flottes GameLift sont uniquementaccessibles via les ports autorisés dans la configuration de la flotte. Vous pouvez afficher lesparamètres de port de la flotte à l'aide de la commande describe-fleet-port-settings.

La bonne pratique consiste à ouvrir des ports pour l'accès à distance uniquement lorsque vous enavez besoin et à les fermer lorsque vous avez terminé. Utilisez la commande update-fleet-port-settings pour ajouter un paramètre de port pour la connexion à distance (22 pour SSH ou 3389pour RDP, par exemple). Pour la valeur de plage d'adresses IP, spécifiez les adresses IP pour lespériphériques que vous voulez utiliser pour la connexion (converties au format CIDR). Exemple

$ 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. Ouvrez un client de connexion à distance. Utilisez le Bureau à distance pour Windows ou SSH pourles instances Linux. Connectez-vous à l'instance à l'aide de l'adresse IP, du paramètre de port et desinformations d'identification d'accès.

Exemple SSH :

ssh -i MyPrivateKey.pem gl-user-remote@192.0.2.0

Affichage de fichiers sur des instances distantesLorsque vous êtes connecté à une instance à distance, vous disposez d'un accès utilisateur et administratifcomplet. Cela signifie que vous avez également la possibilité de produire des erreurs et des défaillancesdans l'hébergement de jeux. Si l'instance héberge des jeux avec des joueurs actifs, vous courez le risquede bloquer des sessions de jeu et de déconnecter des joueurs, ainsi que de perturber les processus d'arrêtdes jeux et de causer des erreurs dans les données et les journaux de jeu enregistrés.

L'hébergement de ressources sur une instance est disponible dans les emplacements suivants :

• Fichiers de build de jeu. Il s'agit des fichiers inclus dans la version de jeu chargée dans GameLift. Ilscomprennent un ou plusieurs exécutables de serveur de jeux, des actifs et des dépendances. Cesfichiers se trouvent dans un répertoire racine appelé game :• Sous Windows : c:\game• Sous Linux : /local/game

• Fichiers journaux de jeu. Les fichiers journaux générés par votre serveur de jeux sont stockés dans lerépertoire racine game dans le chemin d'accès de répertoire que vous avez désigné.

• GameLift ressources d’hébergement. Fichiers utilisés par le GameLift pour gérer l’hébergement de jeuxse trouvent dans un répertoire racine appelé Whitewater. Ces fichiers ne doivent pas être modifiéspour une raison quelconque.

Version132

Amazon GameLift Manuel du développeurDimensionnement de la capacité d'une flotte

• Configuration d'exécution. La configuration d'exécution de la flotte n'est pas accessible pour lesinstances individuelles. Pour tester les modifications apportées à une configuration d'exécution(chemin de lancement, paramètres de lancement, nombre maximal de processus simultanés) vousdevez mettre à jour la configuration d'exécution au niveau de la flotte (voir l'action du kit SDK AWSUpdateRuntimeConfiguration ou update-runtime-configuration de l'AWS CLI).

• Données de flotte. Les attributs du parc auquel l’instance appartient sont stockés dans un fichier JSON.Ces informations peuvent être utilisées par les processus serveur qui s’exécutent sur l’instance. Le fichierJSON est stocké à l’emplacement suivant :• Sous Windows : C:\GameMetadata\gamelift-metadata.json• Sous Linux : /local/gamemetadata/gamelift-metadata.json

• Certificat TLS Si l'instance se trouve sur un parc pour lequel la génération de certificats TLS est activée,les fichiers de certificat, y compris le certificat, la chaîne de certificats, la clé privée et le certificat racine,sont stockés à l'emplacement suivant :• Sous Windows : c:\\GameMetadata\Certificates• Sous Linux : /local/gamemetadata/certificates/

Dimensionnement de la capacité d'une flotteGameLift

La capacité de la flotte, mesurée en instances, décrit le nombre de sessions de jeu qu'une flotte peuthéberger simultanément et, par extension, le nombre de joueurs simultanés. L'une des tâches les plusdifficiles avec l'hébergement de jeux est de maintenir une capacité suffisante pour accueillir tous lesjoueurs sans gaspiller de l'argent en ressources lorsqu'elles ne sont pas nécessaires. En savoir plus sur lafaçon dont fonctionne la mise à l'échelle des capacités (p. 6) dans GameLift.

Vous disposez d'un contrôle total sur la mise à l'échelle d'un parc. Vous pouvez définir la capacité d'uncertain nombre d'instances, ou vous pouvez tirer parti de la scalabilité automatique pour ajuster la capacitéen fonction de la demande réelle des joueurs. Nous vous recommandons de commencer par activerl'option de scalabilité automatique Suivi de la cible. Le suivi des cibles est un outil de dimensionnementefficace et facile à utiliser qui vous aide à maintenir suffisamment de ressources d'hébergement pouraccueillir les joueurs et juste assez de ressources supplémentaires pour gérer les pics inattendus dans lademande de joueurs. Pour la plupart des jeux, le suivi des cibles est la solution la plus efficace.

Les rubriques de cette section fournissent une aide détaillée sur les tâches suivantes :

• Définir des limites de capacité maximale et minimale pour le dimensionnement des capacités (p. 134)• Définir manuellement des niveaux de capacité (p. 135)• Activer la scalabilité automatique avec Suivi de la cible (p. 138)• Gérer la scalabilité automatique basée sur les règles (fonction avancée) (p. 139)• Désactiver temporairement la scalabilité automatique (p. 136)

La plupart des activités de dimensionnement de la flotte peuvent être effectuées à l'aide de la consoleGameLift. Vous pouvez également utiliser le kit SDK AWS ou l'AWS CLI avec l'API de service GameLiftpour le dimensionnement de toute la flotte.

Pour définir la capacité de la flotte dans la console1. Ouvrez la console Amazon GameLift à l'adresse https://console.aws.amazon.com/gamelift/.2. Sur la page Fleets (Flottes), cliquez sur le nom d'une flotte active pour ouvrir la page de détails

correspondante. (Vous pouvez également accéder à la page des détails d'une flotte via Dashboard(Tableau de bord).)

Version133

Amazon GameLift Manuel du développeurDéfinir les limites de capacité d'une flotte

3. Ouvrez l'onglet Dimensionnement pour afficher les métriques de mise à l'échelle de l'historique etpour afficher ou modifier les paramètres actuels. Les paramètres se situent sous le graphique desmétriques. Dans cette section, vous pouvez afficher ou mettre à jour les limites de dimensionnement,définir manuellement la capacité du parc, activer ou désactiver la scalabilité automatique, activer lascalabilité automatique basée sur la cible, puis afficher toutes les stratégies de scalabilité automatiqueactives.

Rubriques• Définir les limites de capacité d'une flotte GameLift (p. 134)• Réglage manuel de la capacité d'une flotte GameLift (p. 135)• Dimensionner automatiquement la capacité de la flotte avec GameLift (p. 137)

Définir les limites de capacité d'une flotte GameLiftLa taille de parc est déterminée par le nombre d'instances qu'il contient. Chaque parc comporte une limiteminimale et maximale définies, que vous pouvez définir en fonction des besoins de votre jeu. Toutes lesdemandes de modification de capacité du parc (soit par la scalabilité automatique ou le dimensionnementmanuel) doivent entrer dans les limites actuelles. Par défaut, les limites applicables aux nouveaux parcssont définies sur un minimum de 0 instance et un maximum de 1 instance. Avant de dimensionner à lahausse un parc, vous aurez besoin d'ajuster les limites du parc.

Si vous dimensionnez automatiquement une flotte, la limite maximale permet à GameLift de dimensionnerà la hausse la flotte en fonction des besoins pour répondre à la demande des joueurs, tout en évitant unehausse des coûts d'hébergement, comme cela peut se produire lors d'une attaque DDOS. DéfinissezCloudWatch sur une alarme lorsque la capacité approche la limite maximale, afin de pouvoir évaluer lasituation et ajuster manuellement en fonction des besoins. (Vous pouvez également définir une alerte defacturation pour surveiller les coûts AWS.) La limite minimale est utile lorsque vous souhaitez vous assurerque vous avez toujours une disponibilité d'hébergement à tout moment.

Les limites s'appliquent également aux parcs mis à l'échelle manuellement. Avant d'ajuster la capacitédu parc sur une valeur en dehors de la plage limite, vous devez modifier les limites. Étant donné quela capacité du parc a un impact important sur la disponibilité du jeu et l'expérience des joueurs, lafonctionnalité de limite permet d'ajouter une couche de contrôle sur la capacité.

Vous pouvez définir les limites de capacité d'une flotte sur la console GameLift ou à l'aide de l'AWS CLI. Lestatut de du parc doit être Actif.

Pour définir les limites de capacitéConsole

1. Ouvrez la console Amazon GameLift à l'adresse https://console.aws.amazon.com/gamelift/.2. Sur la page Fleets (Flottes), cliquez sur le nom d'une flotte active pour ouvrir la page de

détails correspondante. (Vous pouvez également accéder à la page des détails d'une flotte viaDashboard (Tableau de bord).)

3. Ouvrez l'onglet Dimensionnement pour afficher les métriques de mise à l'échelle de l'historiqueet pour afficher ou modifier les paramètres actuels. Les paramètres de mise à l'échelle se situentsous le graphique des métriques.

4. Sous Limites d'instance, définissez le nombre minimum et maximum d'instances. Pour chaquecontrôle, validez vos modifications en cliquant sur le bouton .

Si le nombre d'instances souhaité actuel est en dehors de la nouvelle plage de limites, vousobtenez une erreur. Dans ce cas, vous devez d'abord ajuster les limites d'instance du parc afin

Version134

Amazon GameLift Manuel du développeurDéfinir manuellement la capacité de la flotte

qu'elles figurent dans la nouvelle plage de limites. Cette opération peut être effectuée sous l'ongletDimensionnement. Si la flotte utilise la scalabilité automatique, vous devez désactiver la scalabilitéautomatique, ajuster manuellement le nombre d'instances souhaitées et définir la nouvelle plagede limites, puis réactiver la scalabilité automatique.

Les nouvelles limites sont immédiatement reflétées dans le graphique dans la partie supérieure del'onglet Dimensionnement.

AWS CLI

1. Vérifiez les paramètres de capacité actuels. Dans une fenêtre de ligne de commande, utilisezla commande describe-fleet-capacity avec l'ID de la flotte dont vous voulez modifier la capacité.Cette commande retourne un objet FleetCapacity qui inclut le nombre d'instances actuel et leslimites de capacité. Déterminez si les nouvelles limites d'instance seront suffisantes pour recevoirles paramètres d'instances souhaitées actuels.

aws gamelift describe-fleet-capacity --fleet-id <unique fleet identifier>

2. Mettez à jour les paramètres de limite. Dans une fenêtre de ligne de commande, utilisez lacommande update-fleet-capacity avec les paramètres suivants. Vous pouvez ajuster les deuxlimites d'instance et le nombre d'instances souhaitées avec la même commande.

--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]

Exemple :

aws gamelift update-fleet-capacity--fleet-id fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa--max-size 10--min-size 1--desired-instances 10

Version copiable :

aws gamelift update-fleet-capacity --fleet-id fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa --max-size 10 --min-size 1 --desired-instances 10

Si votre demande aboutit, l'ID de flotte est renvoyé. Si la nouvelle valeur max-sizeou min-size est enconflit avec le paramètre desired-instances actuel, une erreur est retournée.

Réglage manuel de la capacité d'une flotte GameLiftLorsque vous créez un nouveau parc, la capacité de parc est automatiquement définie sur une seuleinstance. En réponse, GameLift démarre une nouvelle instance avec des processus serveur de jeuxcomme configuré. Pour modifier la capacité de parc, vous pouvez activer la scalabilité automatique ouvous pouvez définir manuellement le nombre d'instances que vous voulez pour le parc. En savoir plus surDimensionnement de la capacité d'une flotte (p. 6).

La définition manuelle de la capacité d'un parc peut être utile lorsque la scalabilité automatique n'est pasnécessaire ou lorsque vous avez besoin de maintenir la capacité à un nombre arbitraire d'instances de

Version135

Amazon GameLift Manuel du développeurDéfinir manuellement la capacité de la flotte

manière temporaire ou définitive. Lors de la définition manuelle de la capacité souhaitée, gardez à l'espritque cette action aura un impact sur la capacité réelle du parc uniquement si (1) il n'y a pas de stratégiesde dimensionnement automatique pour le parc, ou si (2) la scalabilité automatique est désactivée. Si lascalabilité automatique est activée, elle réinitialisera immédiatement la capacité souhaitée en fonction deses propres règles de dimensionnement.

Vous pouvez définir manuellement la capacité de la flotte sur la console GameLift ou à l'aide de l'AWS CLI.Le statut de du parc doit être Actif.

Désactivation du dimensionnement automatiqueLa désactivation de la scalabilité automatique vous permet de désactiver toute la scalabilité automatiqued'un parc et de revenir à un dimensionnement manuel. Même si vous pouvez toujours supprimerla stratégie de scalabilité automatique d'un parc, cette fonctionnalité vous permet de désactivertemporairement la scalabilité automatique, tout en conservant les stratégies pour une utilisation ultérieure.Par exemple, si vous voulez effectuer un dimensionnement à la hausse en vue d'un prochain événementmajeur, vous pouvez désactiver la scalabilité automatique, définir manuellement la capacité de parcsouhaitée, puis, une fois l'événement en cours, réactiver la scalabilité automatique. Lorsque la scalabilitéautomatique est désactivée, toutes les activités de scalabilité automatique du parc sont arrêtées, y compristoutes les stratégies actuellement actives et toutes les stratégies qui peuvent être créées à l'avenir. Vouspouvez activer/désactiver le dimensionnement automatique sur la console GameLift (consultez l'étape 4« Pour définir manuellement la capacité »).

Pour définir manuellement la capacité de la flotteConsole

1. Ouvrez la console Amazon GameLift à l'adresse https://console.aws.amazon.com/gamelift/.2. Sur la page Fleets (Flottes), cliquez sur le nom d'une flotte active pour ouvrir la page de

détails correspondante. (Vous pouvez également accéder à la page des détails d'une flotte viaDashboard (Tableau de bord).)

3. Ouvrez l'onglet Dimensionnement pour afficher les métriques de mise à l'échelle de l'historiqueet pour afficher ou modifier les paramètres actuels. Les paramètres de mise à l'échelle se situentsous le graphique des métriques.

4. Sous Auto-Scaling Policies (Stratégies de scalabilité automatique), cochez la case « Disableall scaling policies » (« Désactiver toutes les stratégies de mise à l'échelle ») et validez vosmodifications en cliquant sur le bouton . Ce paramètre arrête toutes les actions de scalabilitéautomatique pour le parc. Il est judicieux de faire cela, même si le parc n'a actuellement aucunestratégie, car cela empêchera que des stratégies nouvellement créés ne prennent effet. Une foisque vous avez validé cette modification, le tableau listant les stratégies de dimensionnementactives indique que toutes les stratégies sont « désactivées ».

5. Sous Stratégies de scalabilité automatique, en regard de l'option « Ajuster manuellement lenombre d'instances souhaitées sur... », spécifiez le nombre d'instances pour le parc. Cettevaleur indique à GameLift le nombre d'instances actives à maintenir dans un état actif et prêtes àhéberger des sessions de jeu. Validez la modification en cliquant sur le bouton .

Si la valeur des nouvelles instances souhaitées est en dehors des limites de capacité du parc,vous obtiendrez une erreur. Dans ce cas, vous devez d'abord ajuster les limites d'instance duparc pour permettre le nouveau nombre d'instances souhaitées. Les limites d'instance peuventégalement être définies sous l'onglet Dimensionnement.

Dès que vous validez les modifications apportées aux limites d'instance et les niveaux dedimensionnement manuel, les nouvelles valeurs reflétées dans le graphique en haut de l'ongletDimensionnement. GameLift commence immédiatement à répondre aux modifications apportées parle déploiement d'instances supplémentaires ou l'arrêt des instances superflues. Lorsque ce processus

Version136

Amazon GameLift Manuel du développeurDimensionnement automatique de la capacité d'une flotte

est terminé, le nombre d'instances à l'état Actif change pour correspondre à la valeur souhaitéenouvellement mise à jour. Ce processus peut prendre un certain temps.

AWS CLI

1. Vérifiez les paramètres de capacité actuels. Dans une fenêtre de ligne de commande, utilisezla commande describe-fleet-capacity avec l'ID de la flotte dont vous voulez modifier la capacité.Cette commande retourne un objet FleetCapacity qui inclut le nombre d'instances actuel et leslimites de capacité. Déterminez si le nombre de nouvelles instances se situe entre les limitesminimale et maximale.

aws gamelift describe-fleet-capacity --fleet-id <unique fleet identifier>

2. Mettez à jour la capacité souhaitée. Utilisez la commande update-fleet-capacity avec l'ID de laflotte et une nouvelle valeur desired-instances. Si cette valeur est en dehors de la plage de limitesactuelle, incluez des valeurs d'ajustement de limite dans cette même commande.

--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]

Exemple :

aws gamelift update-fleet-capacity--fleet-id fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa--desired-instances 5--max-size 10--min-size 1

Version copiable :

aws gamelift update-fleet-capacity --fleet-id fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa --desired-instances 5 --max-size 10 --min-size 1

Si votre demande aboutit, l'ID de flotte est renvoyé. Si le nouveau paramètre desired-instances est endehors des limites minimale/maximale, une erreur est retournée.

Dimensionner automatiquement la capacité de la flotteavec GameLiftUtilisez la scalabilité automatique pour mettre à l'échelle automatiquement la capacité de votre parc enfonction de l'activité du serveur de jeux. Au fur et à mesure que les joueurs arrivent et démarrent dessessions de jeu, la scalabilité automatique peut ajouter d'autres instances ; dès que la demande desjoueurs diminue, la scalabilité automatique peut résilier les instances inutiles. La scalabilité automatiqueest une manière efficace de minimiser vos ressources et coûts d'hébergement, tout en fournissant uneexpérience joueur simple et rapide. En savoir plus sur la façon dont le dimensionnement automatique (p. 7)fonctionne dans GameLift

Le dimensionnement automatique s'effectue en créant des stratégies de dimensionnement qui fournissentdes instructions à GameLift pour un dimensionnement à la hausse ou à la baisse. Il existe deux types destratégies de dimensionnement, basées sur la cible et basées sur des règles. L'approche basée sur lacible — Suivi de la cible — offre une solution complète ; elle est recommandée comme étant l'option la plus

Version137

Amazon GameLift Manuel du développeurDimensionnement automatique de la capacité d'une flotte

simple et la plus efficace. Les stratégies de dimensionnement basées sur la cible, qui nécessitent que vousdéfinissiez chaque aspect du processus de décision de la scalabilité automatique, sont utiles pour résoudredes problèmes spécifiques. Il est préférable d'utiliser en supplément la scalabilité automatique basée sur lacible.

Le dimensionnement automatique basé sur la cible peut être gérée à l'aide de la console GameLift ou del'interface de ligne de commande AWS ou du kit SDK AWS. La scalabilité automatique basée sur les règlesest gérée à l'aide de l'interface de ligne de commande AWS ou du kit SDK AWS uniquement, même si vouspouvez afficher des stratégies de dimensionnement basées sur les règles dans la console.

Rubriques• Dimensionner automatiquement avec le suivi de la cible (p. 138)• Mise à l'échelle automatique avec des stratégies basées sur les règles (p. 139)

Dimensionner automatiquement avec le suivi de la cibleLe suivi de la cible ajuste les niveaux de capacité à partir d'une seule métrique de parc clé : « Pourcentagede sessions de jeu disponibles ». Cette métrique mesure le nombre d'emplacements de session dejeu disponibles à la capacité actuelle — davantage de sessions de jeu susceptibles d'être démarréesimmédiatement. En effet, cette métrique représente la mémoire tampon du parc pour faire face auxaugmentations brutales de la demande des joueurs.

La raison principale du maintien d'une capacité de mémoire tampon est le temps d'attente du joueur.Lorsque des emplacements de session de jeu sont prêts et en attente, le temps nécessaire pour obtenirde nouveaux joueurs dans les sessions de jeu peuvent être mesurés en secondes. Si aucune ressourcen'est disponible, les joueurs doivent patienter que les sessions de jeu existantes se terminent ou que denouvelles ressources deviennent disponibles. Le temps nécessaire au démarrage de nouvelles instanceset les processus serveur peuvent prendre plusieurs minutes.

Lors de la configuration de suivi de la cible, vous spécifiez simplement la taille du tampon que le parcdoit maintenir. Étant donné que la métrique « percent available game sessions (pourcentage de sessionsde jeu disponibles) » mesure le pourcentage de ressources disponibles, la taille réelle du tamponest un pourcentage de la capacité totale de la flotte. GameLift ajoute ou retire autant d'instances quenécessaire pour maintenir la taille de tampon cible. Le choix d'une taille du tampon dépend de la façondont vous voulez hiérarchiser la réduction du temps d'attente des joueurs par rapport au contrôle des coûtsd'hébergement. Avec un tampon de grande taille, vous minimisez les temps d'attente, mais vous pouvezégalement payer pour des ressources supplémentaires qui peuvent ne pas être utilisées. Si vos joueurssont plus tolérant en ce qui concerne les temps d'attente, vous pouvez réduire les coûts en définissant untampon plus petit.

Pour définir le suivi de la cible

Console

1. Ouvrez la console Amazon GameLift à l'adresse https://console.aws.amazon.com/gamelift/.2. Sur la page Fleets (Flottes), cliquez sur le nom d'une flotte active pour ouvrir la page de

détails correspondante. (Vous pouvez également accéder à la page des détails d'une flotte viaDashboard (Tableau de bord).)

3. Ouvrez l'onglet Dimensionnement. Cet onglet affiche les métriques de mise à l'échelle del'historique du parc et contient des contrôles pour l'ajustement des paramètres de mise à l'échelleactuels. Les paramètres de mise à l'échelle se situent sous le graphique des métriques.

4. Sous Limites d'instance, vérifiez que les limites minimale et maximale sont appropriées pour leparc. Lorsque la scalabilité automatique est activée, la capacité peut ajuster n'importe quel niveauentre ces deux limites.

5. Sous Stratégies de dimensionnement automatique, cochez l'option permettant de maintenir untampon de disponibilité de session de jeu de X pour cent. Définissez une taille de tampon, puis

Version138

Amazon GameLift Manuel du développeurDimensionnement automatique de la capacité d'une flotte

cliquez sur le bouton pour enregistrer les paramètres de scalabilité automatique. Une fois quevous avez enregistré les paramètres, une nouvelle stratégie basée sur la cible est ajoutée à latable Stratégies de dimensionnement .

6. Pour activer la scalabilité automatique pour la flotte, vérifiez que l'option Disable all scaling policiesin the fleet (Désactiver toutes les stratégies de mise à l'échelle dans la flotte) est désélectionnée.Si cette option est sélectionnée, toutes les stratégies, y compris la nouvelle stratégie de suivi de lacible, sont désactivées. Cet état est indiqué dans la table Stratégies de dimensionnement.

AWS CLI

1. Définissez les limites de capacité. Définissez une ou les deux valeurs de limite à l'aide de lacommande update-fleet-capacity. Pour obtenir de l'aide, consultez Définir les limites de capacitéd'une flotte GameLift (p. 134).

2. Créez une stratégie. Ouvrez une fenêtre de ligne de commande et utilisez la commande put-scaling-policy avec les valeurs de paramètre de votre stratégie. Pour mettre à jour une stratégieexistante, spécifiez le nom de la stratégie et indiquez une version complète de la stratégie mise àjour.

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

Exemple :

$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"

Version 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"

Mise à l'échelle automatique avec des stratégies basées sur lesrèglesLes stratégie de dimensionnement basées sur les règles fournissent un contrôle précis lors de lascalabilité automatique de la capacité d'un parc en réponse à l'activité des joueurs. Pour chaquestratégie, vous pouvez lier le dimensionnement de parc de plusieurs métriques de parc, identifier unseuil de déclenchement, et personnaliser l'événement de réponse par un dimensionnement à la hausseou à la baisse. Les stratégies basées sur les règles sont particulièrement utiles pour compléter ledimensionnement basé sur la cible pour gérer des circonstances particulières.

Une stratégie basée sur des règles effectue la déclaration suivante : « Si une métrique de flotte atteint oucroise une valeur de seuil pendant un certain laps de temps, modifier la capacité de la flotte d'un certain

Version139

Amazon GameLift Manuel du développeurDimensionnement automatique de la capacité d'une flotte

niveau. » Cette rubrique décrit la syntaxe utilisée pour construire une déclaration de stratégie et fournit uneaide pour la création et la gestion de vos règles basées sur des règles.

Gérer les stratégies basées sur des règles

Créez, mettez à jour ou supprimez des stratégies basées sur des règles à l'aide du kit SDK AWS ou del'AWS CLI avec l'API du service GameLift. Vous pouvez afficher tous les stratégies actives sur la consoleGameLift.

Pour désactiver temporairement toutes les stratégies de dimensionnement d'une flotte, utilisez lacommande de l'interface de ligne de commande AWS stop-fleet-actions.

Pour créer ou mettre à jour une stratégie de dimensionnement basé sur des règles (interface deligne de commande AWS) :

1. Définissez les limites de capacité. Définissez une ou les deux valeurs de limite à l'aide de lacommande update-fleet-capacity. Pour obtenir de l'aide, consultez Définir les limites de capacité d'uneflotte GameLift (p. 134).

2. Créez une stratégie. Ouvrez une fenêtre de ligne de commande et utilisez la commande put-scaling-policy avec les valeurs de paramètre de votre stratégie. Pour mettre à jour une stratégie existante,spécifiez le nom de la stratégie et indiquez une version complète de la stratégie mise à jour.

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

Exemple :

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

Version 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

Pour supprimer une stratégie de dimensionnement basé sur des règles à l'aide de l'interface deligne de commande AWS :

• Ouvrez une fenêtre de ligne de commande et utilisez la commande delete-scaling-policy avec l'ID de laflotte et le nom de la stratégie.

Version140

Amazon GameLift Manuel du développeurDimensionnement automatique de la capacité d'une flotte

Exemple :

aws gamelift delete-scaling-policy--fleet-id fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa--name "Scale up when AGS<50"

Version copiable :

aws gamelift delete-scaling-policy --fleet-id fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa --name "Scale up when AGS<50"

Syntaxe pour les règles de mise à l'échelle automatique

Pour créer une instruction de stratégie de dimensionnement basée sur des règles, vous devez spécifier sixvariables :

Si <nom de métrique> demeure <opérateur de comparaison> <valeur de seuil> pour<période d'évaluation>, remplacez la capacité de la flotte en utilisant <type d'ajustement> sur/par <valeur d'ajustement>.

Par exemple, cette déclaration de stratégie déclenche un événement de dimensionnement à la haussechaque fois que la capacité supplémentaire d'un parc (ressources d'hébergement disponibles qui ne sontpas en cours d'utilisation) est inférieure à ce qui est nécessaire pour traiter 50 nouvelles sessions de jeu :

Si AvailableGameSessions reste à less than 50 pendant 10 minutes, modifier à la capacité de laflotte avec ChangeInCapacity par 1 instances.

Nom de métrique

Pour déclencher un événement de dimensionnement, liez une stratégie de scalabilité automatiqueà l'une des métriques spécifiques à un parc suivantes. Consultez Métriques GameLift pour lesflottes (p. 202) pour des descriptions de métrique plus complètes.• Activation de sessions de jeu• Sessions de jeu actives• Sessions de jeu disponibles• Pourcentage de sessions de jeu disponibles• Instances actives• Sessions de joueur disponibles• Sessions de joueur actuelles• Instances inactives• Pourcentage d'instances inactives

Les métriques suivantes peuvent être utilisées si le parc est inclus dans une file d'attente de sessionsde jeu :• Profondeur de file d'attente (spécifique à une flotte) – Nombre de demandes de session de jeu pour

lesquelles cette flotte constitue le meilleur emplacement d'hébergement disponible.• Temps d'attente (spécifique à une flotte) – Temps d'attente spécifique à une flotte. Durée pendant

laquelle la demande de session de jeu plus ancienne attend d'être traitée. Comme pour laprofondeur de file d'attente, cette métrique reflète uniquement les demandes de session de jeupour lesquelles cette flotte constitue le meilleur emplacement d'hébergement disponible. Le tempsd'attente d'une flotte correspond à la durée passée en file d'attente de la plus ancienne demandeactuelle.

Version141

Amazon GameLift Manuel du développeurDimensionnement automatique de la capacité d'une flotte

Opérateur de comparaison

Cette variable indique à GameLift comment comparer les données de métrique par rapport à la valeurde seuil. Les opérateurs de comparaison valides incluent : supérieur à (>), inférieur à (<), supérieur ouégal à (>=) ou inférieur ou égal à (<=).

Valeur de seuil

Lorsque la valeur de métrique spécifiée atteint ou croise la valeur de seuil , elle peut déclencher unévénement de mise à l'échelle. En fonction de la métrique sélectionnée, cela peut indiquer un nombrede sessions de joueur, de sessions de jeu, d'instances ou de demandes de session de jeu. Cettevaleur est toujours un nombre entier positif.

Période d'évaluation

La métrique doit atteindre ou croiser la valeur de seuil pendant toute la durée de la périoded'évaluation avant de déclencher un événement de mise à l'échelle. La longueur de la périoded'évaluation est consécutive ; si la métrique s'écarte du seuil, la période d'évaluation recommence.

Type et valeur d'ajustement

Les variables de cet ensemble fonctionnent ensemble pour spécifier la façon dont GameLift doit ajusterla capacité du parc lorsqu'un événement de dimensionnement est déclenché. Vous avez le choix entretrois types possibles d'ajustements :• Change in capacity (Modifications de la capacité) – Augmenter ou réduire la capacité actuelle d'un

nombre d'instances spécifié. Définissez la valeur d'ajustement en fonction du nombre d'instancesà ajouter ou à retirer du parc. Les valeurs positives ajoutent des instances, tandis que les valeursnégatives retirent des instances. Par exemple, la valeur « -10" diminue le parc de 10 instances,quelle que soit la taille totale du parc.

• Percent change in capacity (Pourcentage de changement de la capacité) – Augmenter ou réduirela capacité actuelle en fonction d'un pourcentage spécifié. Définissez la valeur d'ajustement enfonction du taux d'augmentation ou de réduction de capacité que vous voulez appliquer au parc. Lesvaleurs positives ajoutent des instances, tandis que les valeurs négatives retirent des instances. Parexemple, pour une flotte avec 50 instances, un changement de pourcentage égal à « 20 » ajoute dixinstances au parc.

• Exact capacity (Capacité exacte) – Définir des instances souhaitées pour une valeur spécifique.Définissez la valeur d'ajustement sur le nombre exact d'instances que vous voulez maintenir dans leparc.

Conseils pour le dimensionnement automatique basée sur des règles

Les suggestions suivantes peuvent vous aider à tirer le meilleur parti de la scalabilité automatique avec desstratégies basées sur des règles.

Utilisation de plusieurs stratégies

Vous pouvez avoir plusieurs stratégies de scalabilité automatique en vigueur pour un même parc en mêmetemps. Le scénario le plus courant consiste à avoir une stratégie basée sur la cible pour gérer la plupartdes besoins de dimensionnement et d'utiliser des stratégies basées sur des règles pour gérer les caslimites. Cependant, il n'y a pas de limite à l'utilisation de plusieurs stratégies.

Plusieurs stratégies se comportent de façon indépendante. Gardez à l'esprit qu'il n'est pas possiblede contrôler la séquence des événements de dimensionnement. Par exemple, si vous avez plusieursstratégies pour une augmentation de la capacité, il est possible que l'activité des joueurs déclencheplusieurs événements de dimensionnement en même temps. Par exemple, les effets de deux stratégiesd'augmentation de capacité peuvent facilement s'aggraver s'il est possible que l'activité des joueursdéclenche les deux métriques. Il est nécessaire aussi de surveiller les stratégies qui se déclenchent entre

Version142

Amazon GameLift Manuel du développeurUtilisation de files d'attente sur plusieurs régions

elles. Par exemple, vous pouvez créer une boucle sans fin si vous créez des stratégies d'augmentation etde réduction de la capacité qui définissent la capacité au-delà du seuil de l'autre.

Définir une capacité maximale et minimale

Chaque parc comporte une limite de capacité maximale et minimale. Cette fonctionnalité estparticulièrement importante lorsque vous utilisez la scalabilité automatique. La scalabilité automatique nedéfinira jamais la capacité sur une valeur en dehors de cette plage. Par défaut, les flottes nouvellementcréées ont un minimum de 0 et un maximum de 1. Pour que votre stratégie de scalabilité automatiqueaffecte la capacité comme prévu, vous devez augmenter la valeur maximum.

La capacité de la flotte est également restreinte par les limites en termes de type d'instance de la flottedans votre compte AWS. Vous ne pouvez pas définir un minimum et un maximum en dehors des limites deservice et de compte.

Métriques de suivi après une modification de la capacité

Après modification de la capacité dans le cadre d'une stratégie de dimensionnement automatique,GameLift attend dix minutes avant de répondre aux déclenchements de cette même stratégie. Cette attentepermet à GameLift d'ajouter de nouvelles instances, de lancer les serveurs de jeux, de connecter desjoueurs et de démarrer la collecte de données des nouvelles instances. Pendant ce temps, GameLiftcontinue à évaluer la stratégie par rapport aux métriques et à suivre la période d'évaluation de la stratégie,laquelle redémarre dès qu'un événement de dimensionnement est déclenché. Cela signifie qu'une stratégiede dimensionnement pourrait déclencher un autre événement de dimensionnement immédiatement àl'issue du temps d'attente.

Il n'y a pas de temps d'attente entre les événements de dimensionnement déclenchés par différentesstratégies de scalabilité automatique.

Utilisation de files d'attente sur plusieurs régionsUtilisez des files d'attente pour créer des groupes de flottes qui englobent plusieurs régions, et permettre leplacement des sessions de jeu dans n'importe quelle flotte de la file d'attente. Les files d'attente offrent denombreux avantages par rapport aux flottes individuelles, notamment une efficacité accrue des placementsdes sessions de jeux et la possibilité d'utiliser la latence du joueur lors de la sélection d'un emplacementde jeu. Le service de serveurs clients spécifie une file d'attente lors de la demande des placements denouvelles sessions de jeux ou de mise en relation. Utilisez l'AWS Command Line Interface (interface deligne de commande) ou la console Amazon GameLift pour créer, modifier et suivre les métriques d'une filed'attente.

Rubriques• Conception d'une file d'attente de session de jeu (p. 143)• Création d'une file d'attente (p. 149)• Afficher vos files d'attente (p. 152)

Conception d'une file d'attente de session de jeuAmazon GameLift utilise les files d'attente pour traiter les demandes de nouveaux placements de sessionsde jeu et trouver les ressources d'hébergement pour de nouvelles sessions de jeu. La façon dont vousconcevez votre file d'attente détermine (1) où Amazon GameLift recherche les ressources disponibles, et(2) comment Amazon GameLift évalue les ressources disponibles pour faire le meilleur choix pour chaquenouvelle session de jeu. Utilisez les files d'attente pour offrir la meilleure expérience possible à vos joueurset vous assurer que les ressources d'hébergement pour lesquelles vous payez sont utilisées efficacement.

Version143

Amazon GameLift Manuel du développeurConception d'une file d'attente

Les files d'attente sont requises avec les fonctions Amazon GameLift suivantes :

• Mise en relation avec FlexMatch (voir Concevoir un FlexMatch matchmaker (p. 78))• Parcs d'instances Spot (consultez Utilisation d'instances Spot avec GameLift (p. 115))

En savoir plus sur les files d'attente dans the section called “Exécution des sessions de jeu” (p. 5). Pourplus d'informations sur la création d'une file d'attente, consultez Création d'une file d'attente (p. 149). Pourplus d'informations sur la création de nouvelles sessions de jeu avec les files d'attente, consultez Créationde sessions de jeu (p. 55).

Pourquoi utiliser des files d'attente ?Nous recommandons vivement d'utiliser les files d'attente de placement de session de jeu, même si vousn'utilisez pas une fonction Amazon GameLift qui les requiert. Même si vous avez toujours la possibilité decréer manuellement une session de jeu sur une flotte spécifique (CreateGameSession), les files d'attente(en particulier celles qui s'étendent sur plusieurs régions) peuvent offrir des avantages stratégiques pourvous et vos joueurs. ——

• Minimiser la latence pour une meilleure expérience du joueur. Lorsqu'une demande de placementde session de jeu inclut des données de latence pour les joueurs, FleetIQ garantit que les joueursobtiennent la plus faible latence possible sur le serveur de jeux. Définissez des règles supplémentairesafin de minimiser les différences de latence entre les joueurs et d'établir un équilibre entre la rapidité dela mise en jeu et la meilleure expérience de jeu possible.

• Profiter de parcs d'instances Spot à bas prix. Vous pouvez ajouter des parcs d'instances Spot, qui offrentdes coûts d'hébergement nettement inférieurs, à une file d'attente, à tout moment. Lorsque les parcsd'instances Spot sont disponibles, FleetIQ place les nouvelles sessions de jeu dans les flottes disposantde la latence et du prix spot les plus faibles.

• Placer les nouveaux jeux plus rapidement à haute capacité. Une seule flotte a une capacité limitée,et une fois cette limite atteinte, les joueurs doivent attendre que des instances supplémentaires soientmises à l'échelle avant que de nouvelles sessions de jeu puissent commencer. Cependant, une filed'attente peut être utilisée pour effectuer immédiatement des placements sur d'autres flottes si la flottepréférée est pleine. De plus, grâce à la scalabilité automatique, chaque parc de la file d'attente s'adapteà mesure qu'il atteint sa pleine capacité. Il est donc peu probable que tous les parcs d'une file d'attentesoient pleins en même temps. Par conséquence, le temps d'attente pour les joueurs est moins affectélors des hausses de demande des joueurs.

• Rendre la disponibilité des jeux plus résistante. Des pannes au niveau des flottes et des régions peuventse produire. Lorsque vous utilisez une file d'attente à plusieurs régions, un ralentissement ou une pannene doit pas affecter l'accès des joueurs à votre jeu. À la place, si une ou plusieurs flottes préférées sontindisponibles, Amazon GameLift peut placer de nouvelles sessions de jeu avec la prochaine meilleureflotte. La scalabilité automatique s'ajuste ensuite à ce changement temporaire de l'activité du parcjusqu'à ce que les parcs préférés soient à nouveau disponibles.

• Utiliser plus efficacement la capacité de la flotte supplémentaire. Pour gérer les augmentationsinattendues de la demande des joueurs, il est logique de disposer d'un accès rapide à une capacitéd'hébergement supplémentaire. Lorsque vous comptez sur une seule flotte pour prendre en chargel'accès des joueurs à votre jeu, vous devez conserver une capacité inutilisée, au cas où. En revanche,les flottes d'une file d'attente peuvent agir comme solutions de secours, la demande accrue des joueursse déplaçant vers des flottes moins utilisées dans d'autres régions, le cas échéant. Par exemple, lorsquela demande est élevée en Asie, la demande est en général faible en Europe. Vos flottes européennespeuvent fournir une capacité supplémentaire pour soutenir les hausses de demande en Asie, mêmelorsqu'elles sont réduites en cas de faible demande.

• Obtenir les métriques sur les placements de sessions de jeu et les performances des files d'attente.Amazon GameLift émet des métriques spécifiques aux files d'attente, notamment des statistiques sur lesréussites et les échecs des placements, le nombre de demandes dans la file d'attente et le temps moyenpassé par les demandes dans la file d'attente. Vous pouvez également consulter ces métriques à l'aidede la console Amazon GameLift ou dans CloudWatch.

Version144

Amazon GameLift Manuel du développeurConception d'une file d'attente

Conseils sur la définition des destinations d'une file d'attenteUne file d'attente contient une liste de destinations auxquelles les demandes de placement de sessionde jeu peuvent être exécutées. Dans la plupart des cas, une destination est une flotte que vous pouvezindiquer par un ID de flotte ou un ID d'alias. Lorsque vous choisissez des destinations pour la file d'attente,tenez compte des consignes et bonnes pratiques suivantes :

• Vous pouvez ajouter n'importe quelle flotte ou alias existant à partir de n'importe quelle région. Ajoutezune flotte dans chaque région où vous souhaitez prendre en charge les joueurs, en particulier si vousutilisez la latence des joueurs pour le placement.

• Si vous attribuez des alias à vos flottes (comme recommandé), il est conseillé d'utiliser les noms d'aliaslors de la définition des destinations de votre file d'attente.

• Toutes les destinations d'une file d'attente doivent exécuter des builds de jeu compatibles avec les clientsde jeu utilisant la file d'attente. N'oubliez pas que les demandes de nouvelles sessions de jeu traitées parla file d'attente peuvent être placées sur n'importe quelle destination de la file d'attente.

• Une file d'attente doit comporter au moins deux flottes et s'étendre sur au moins deux régions. Cetteconception améliore la résilience de l'hébergement en diminuant l'impact des ralentissements de flotte ourégionaux et en gérant plus efficacement les changements inattendus de demande des joueurs.

• L'ordre de la liste des destinations dans une file d'attente est important. Si vous incluez des donnéesde latence dans une demande de placement de session de jeu, Amazon GameLift classe à nouveaules destinations par ordre de priorité afin de trouver les ressources disponibles disposant (1) d'unelatence minimale du joueur et (2) du prix spot le plus faible (le cas échéant). Si vous ne fournissez pas dedonnées de latence, Amazon GameLift suit l'ordre de la liste de destinations. Dans ce cas, les sessionsde jeu seront généralement hébergées sur la première flotte répertoriée et ne seront placées sur desflottes de sauvegarde qu'en cas de besoin.

• Vous devez décider de l'emplacement où créer votre file d'attente (dans quelle région). Idéalement,vous effectuez des demandes de placement de session de jeu via un service de client de jeu, tel qu'unservice de référentiel de session. Si tel est le cas, nous vous recommandons de créer votre file d'attentedans une région géographique proche du lieu où le service de client est déployé. Vous limiterez ainsi lalatence lors de l'envoi de demandes de placement de session de jeu.

• Une file d'attente ne doit pas avoir de parcs avec des configurations de certificat différentes. Lagénération de certificats TLS doit être activée ou désactivée pour toutes les flottes de la file d'attente.

Création d'une file d'attente à plusieurs régionsUne conception à plusieurs régions est recommandée pour toutes les files d'attente, que vous utilisiez ounon des fonctions spéciales, telles que la mise en relation FlexMatch ou les parcs d'instances Spot. Cetteconception peut améliorer la vitesse de placement et la résilience de l'hébergement, et est essentiellelorsque vous utilisez des données de latence pour les joueurs.

Cette rubrique décrit le processus de conception d'une file d'attente à plusieurs régions de base. Pour cetexemple, nous allons utiliser une build de serveur de jeux que nous voulons distribuer aux joueurs de lacôte est de l'Amérique du Nord. Nous avons choisi d'héberger notre jeu dans les régions suivantes : us-east-1 et ca-central-1. Nous avons téléchargé la build du jeu et créé une flotte dans chaque région.

1. Choisissez une région dans laquelle créer la file d'attente. L'emplacement de la file d'attente n'estpeut-être pas important, mais si nous effectuons des demandes de placement via un service de client,nous pouvons réduire la latence des demandes en plaçant la file d'attente dans une région proche dudéploiement du service de client.

2. Créez une nouvelle file d'attente et ajoutez nos flottes comme destinations de la file d'attente.3. Choisissez un ordre de la liste par défaut pour les destinations. GameLift peut évaluer les flottes dans

cet ordre lors de la recherche de ressources d'hébergement disponibles. Si une demande de placementcontient des données de latence pour les joueurs, Amazon GameLift réorganise nos destinations afin de

Version145

Amazon GameLift Manuel du développeurConception d'une file d'attente

donner priorité aux taux de latence les plus faibles. Si aucune donnée de latence n'est fournie, AmazonGameLift utilise l'ordre par défaut.• Si nous prévoyons un grand nombre de demandes sans données de latence, nous allons accorder

plus d'attention à l'ordre de notre liste par défaut et aux flottes que nous répertorions en premier.Sans données de latence, Amazon GameLift placera toujours de nouvelles sessions de jeu sur lapremière flotte répertoriée, lorsqu'elle est disponible, en utilisant uniquement les autres flottes commesauvegarde. Par conséquent, nous voulons une flotte en première position qui (1) est assez puissantepour gérer la plupart de nos joueurs, et (2) est susceptible de fournir la plus haute disponibilité et laplus faible latence à la majorité de nos joueurs.

Dans ce scénario, nous prévoyons que la flotte us-east-1 servira au mieux la plupart de nosjoueurs. Nous choisissons donc un type d'instance haute performance, le configurons pour plusieurssessions de jeu simultanées, le mettons à l'échelle pour un volume de joueurs élevé, et le répertorionsen premier dans notre file d'attente. Notre flotte de sauvegarde ca-central-1 utilise un typed'instance plus petit et moins onéreux tout en gérant une capacité minimale. Les flottes de sauvegardesupplémentaires (si elles sont ajoutées) n'ont pas besoin d'être triées, mais nous pouvons annuler lapriorité des régions susceptibles d'avoir des taux de latence élevés.

• Si nous prévoyons que la plupart des demandes disposent de données de latence, l'ordre de la listeest moins important car FleetIQ lui réattribuera des priorités. Nous souhaitons disposer de flottes danstoutes les régions proches de nos joueurs cibles afin de minimiser le taux de latence. En général,nous voulons des flottes configurées pour gérer la quantité attendue de demande des joueurs. Nousvoulons nous assurer que la flotte en première position est un bon choix pour gérer les demandes nedisposant pas de données de latence.

Dans ce scénario, nous prévoyons que les flottes us-east-1 et ca-central-1 fourniront de faiblestaux de latence et seront fortement utilisées. Les deux flottes utilisent des types d'instances hautesperformances et sont configurées pour plusieurs sessions de jeu simultanées. La demande pour laflotte ca-central-1 sera légèrement inférieure, elle gèrera donc une capacité inférieure.

Au fur et à mesure que notre file d'attente est mise en action, nous pouvons utiliser des données demétrique pour déterminer si la conception tient le coup. Avec les files d'attente, nous effectuons lesmodifications de flotte nécessaires, soit en reconfigurant les flottes existantes, soit en supprimant et enajoutant de nouvelles flottes qui répondent mieux à nos besoins d'hébergement.

Conception des stratégies de latence du joueurSi vos demandes de placement de session de jeu incluent des données de latence pour les joueurs,Amazon GameLift utilise FleetIQ pour s'assurer que les joueurs sont placés dans des sessions de jeu avecla latence la plus faible possible. FleetIQ établit les priorités des destinations d'une file d'attente en fonctionde la latence régionale moyenne pour tous les joueurs de la demande.

Vous pouvez configurer des stratégies de latence du joueur pour affecter la façon dont Amazon GameLiftutilise les données de latence pour les joueurs. Vous pouvez définir des stratégies de latence du joueurpour :

• Définir la latence maximale pour des joueurs individuels. Par défaut, Amazon GameLift place lessessions de jeu en fonction de la latence moyenne de l'ensemble des joueurs de la demande. Cettestratégie garantit qu'une session de jeu n'est pas placée dans un endroit où un joueur subira une latencesupérieure au maximum.

• Utiliser plusieurs stratégies pour assouplir la latence maximale au fil du temps. La définition d'unelatence maximale protège les joueurs contre les jeux à forte latence, mais augmente également lerisque qu'une demande de session de jeu avec des valeurs de latence élevées ne soit jamais exécutée.Vous pouvez utiliser une série de stratégies pour augmenter progressivement la latence maximale aufil du temps. Utilisez cette approche pour équilibrer la façon dont vous fournissez des expériences dejeu intéressantes tout en proposant aux joueurs de participer à des jeux avec un minimum de tempsd'attente.

Version146

Amazon GameLift Manuel du développeurConception d'une file d'attente

Par exemple, vous pouvez définir les stratégies suivantes pour une file d'attente dont le délai est de5 minutes. Les différentes stratégies sont appliquées de façon consécutive, en commençant par la stratégiedont la valeur de latence maximale est la plus faible. Cet ensemble de stratégies commence par unelatence maximale de 50 millisecondes et l'augmente au fil du temps jusqu'à 200 millisecondes. Votredernière stratégie définit la latence maximale absolue autorisée pour tout joueur. Si vous souhaitez vousassurer que toutes les sessions de jeu sont placées indépendamment de la latence, vous pouvez définir lemaximum de la dernière stratégie sur une valeur très élevée.

1. Passer 120 seconds à rechercher une destination dans laquelle toutes les latences pour les joueurs sontinférieures à 50 millisecondes, puis...

2. Passer 120 seconds à rechercher une destination dans laquelle toutes les latences pour les joueurs sontinférieures à 100 millisecondes, puis...

3. Passer le reste du temps d'attente à rechercher une destination dans laquelle toutes les latences pourles joueurs sont inférieures à 200 millisecondes.

Dans cet exemple, la première stratégie est en vigueur pendant les deux premières minutes, la deuxièmependant les troisième et quatrième minutes, et la troisième pendant la cinquième minute jusqu'à ce que ledélai de la demande de placement expire.

Conception d'une file d'attente pour les instances SpotSi vous prévoyez d'utiliser des instances Spot pour vos flottes, vous devez configurer une file d'attente.Idéalement, vous souhaitez configurer une file d'attente résiliente qui tire parti des économies de coûtsavec les parcs d'instances Spot tout en minimisant les risques d'interruptions de session de jeu. Utilisez lesbonnes pratiques suivantes :

• Incluez les flottes provenant de plusieurs régions. Une file d'attente à plusieurs régions augmente larésilience en s'assurant qu'il y a toujours des flottes disponibles pour héberger de nouvelles sessions dejeu.

• Dans chaque région, incluez au moins un parc d'instances Spot et une flotte à la demande. Cetteconception garantit que les sessions de jeu peuvent être placées dans n'importe quelle région même siaucun parc d'instances Spot n'est actuellement viable dans cette région.

• Si vous incluez plusieurs parcs d'instances Spot dans chaque région, utilisez des types d'instancesdifférents pour chaque flotte, de préférence dans la même famille d'instances (c5.large, c5.xlarge,etc.). Cette conception diminue la probabilité que plusieurs parcs d'instances Spot soient indisponiblesou interrompus en même temps. Consultez les données de tarification historiques dans la consoleAmazon GameLift afin de vérifier que vos types d'instance préférés génèrent, en général, des économiessignificatives avec les instances Spot. Ces données affichent la tarification pour les instances Spot et à lademande et fournissent une estimation des économies Spot par instance.

• Afin d'optimiser la capacité de FleetIQ à sélectionner l'instance Spot la moins chère, prévoyez d'inclureles données de latence pour les joueurs pour toutes les régions. Comme indiqué dans la sectionFonctionnement de FleetIQ (p. 147), FleetIQ fonctionne plus efficacement lorsque la priorité desdestinations est redéfinie par région, ce qui est fait lorsque les données de latence sont fournies.

• Si vous ne fournissez pas de données de latence pour les joueurs dans les demandes de placementde sessions de jeu, triez vos destinations par préférence. Par exemple, vous pouvez répertorier lesdestinations par région préférée (parc d'instances Spot suivi par la flotte à la demande). Sinon, vouspouvez répertorier tous vos parcs d'instances Spot en premier.

Fonctionnement de FleetIQLa fonction FleetIQ repose sur le processus de prise de décision suivant lors de la recherche du meilleurplacement possible pour une nouvelle session de jeu.

1. FleetIQ filtre les destinations de la file d'attente afin de supprimer l'un des parcs suivants :

Version147

Amazon GameLift Manuel du développeurConception d'une file d'attente

• Si la demande inclut des données de latence de joueur, FleetIQ évalue les stratégies de latence desjoueurs en file d'attente et supprime toutes les flottes des régions dans lesquelles aucune latence dejoueur ne dépasse la limite maximale d'une stratégie.

• FleetIQ supprime tous les parcs d'instances Spot qui ne sont pas actuellement viables en raison detaux d'interruption inacceptables.

2. FleetIQ définit les priorités de destinations de file d'attente restantes en fonction des éléments suivants :• Si les données de latence des joueurs sont fournie, FleetIQ ordonne de nouveau les destinations de

file d'attente par région, en commençant par la latence de joueur moyenne la plus faible.• Si les données de latence pour les joueurs ne sont pas fournies, FleetIQ utilise la liste d'origine des

destinations de la file d'attente.3. FleetIQ sélectionne une destination à partir de la liste de priorité.

• Si la liste de destination a été hiérarchisée par région, FleetIQ sélectionne le parc dans la région delatence la plus faible dont le prix est le moins élevé. S'il n'y a pas de parcs d'instances Spot viables,n'importe quel parc de cette région peut être sélectionné.

• Si la liste de destination n'est pas hiérarchisée, FleetIQ sélectionne la première flotte viable à partir dela liste d'origine, même s'il y a des parcs d'instances Spot à moindre coût dans la liste.

4. FleetIQ évalue si le parc sélectionné comporte un processus serveur disponible pour héberger unenouvelle session de jeu. Le placement est considéré comme « optimal » lorsque la nouvelle session dejeu est placée dans un parc avec la plus faible latence possible et/ou le prix le plus bas.

5. Si le parc sélectionné n'a pas de ressources disponibles, FleetIQ passe à la prochaine destination listéeet recommence jusqu'à ce qu'il trouve un parc pour héberger la nouvelle session de jeu.

Évaluer les métriques de file d'attenteUtilisez les métriques pour évaluer les performances de vos files d'attente. Vous pouvez égalementconsulter les métriques relatives aux files d'attente à l'aide de la console Amazon GameLift (Affichage desdétails des files d'attente (p. 152)) ou dans Amazon CloudWatch. Les métriques de file d'attente sontdécrites dans Métriques GameLift pour les files d'attente (p. 207).

Les métriques de file d'attente peuvent fournir des détails dans trois domaines principaux :

• Performances globales des files d'attente – Ces métriques indiquent l'efficacité de réponse d'unefile d'attente aux demandes de placement et aident à identifier l'heure et la raison de l'échec desplacements. Pour les files d'attente avec flottes mises à l'échelle manuellement, les temps d'attentemoyens et la profondeur des files d'attente des métriques peuvent indiquer si la capacité d'une filed'attente doit être ajustée.

• FleetIQ Performances – Pour les demandes de placement qui utilisent le filtrage et la priorisationFleetIQ (à savoir, les demandes avec données de latence pour les joueurs), ces métriques indiquent lafréquence à laquelle FleetIQ est capable de trouver le placement optimal pour les nouvelles sessionsde jeu. Le placement optimale peut inclure des ressources avec la plus faible latence possible pourles joueurs ou, lorsque les parcs d'instances Spot sont disponibles, avec le coût le plus bas. Il existeégalement des métriques d'erreur qui identifient les raisons courantes d'échec de placement optimal.

• Placement spécifique à la région – Pour les files d'attente sur plusieurs régions, ces métriques illustrentles placements réussis, répartis par région. Avec les files d'attente qui utilisent FleetIQ, ces donnéesfournissent un aperçu utile de l'emplacement de l'activité des joueurs.

Lors de l'évaluation des mesures pour les performances FleetIQ, tenez compte des conseils suivants :

• Utilisez la métrique « placements réussis » avec les métriques FleetIQ de la plus faible latence et/ou duprix le plus bas pour suivre le taux de placement optimal de la file d'attente.

• Pour augmenter le taux de placement optimal d'une file d'attente, consultez les éléments suivant dans lesmétriques d'erreur :

Version148

Amazon GameLift Manuel du développeurCréation d'une file d'attente

• Si la métrique d'erreur « premier choix non disponible » est élevée, cela signifie en général que leniveau de capacité des flottes de la file d'attente doit être ajustée. Il se peut que le niveau de toutesles flottes de la file d'attente soit élevés, ou il peut y avoir une flotte ou région en particulier qui estoptimisée pour la plupart des placements.

• Si la métrique d'erreur « premier choix non viable » est élevée, cela signifie qu'il faut examiner vosparcs d'instances Spot. Les parcs d'instances Spot sont considérées « non viables » lorsque le tauxd'interruption d'un type d'instance en particulier est trop élevé. Pour résoudre ce problème, modifiez lafile d'attente pour utiliser les parcs d'instances Spot avec différents types d'instances. Comme indiquédans les meilleures pratiques pour les files d'attente avec les parcs d'instances Spot, il est conseilléd'inclure des parcs d'instances Spot avec différents types d'instances dans chaque région.

Création d'une file d'attenteDes files d'attente sont utilisées pour placer de nouvelles sessions de jeu avec les meilleures ressourcesd'hébergement disponibles dans plusieurs flottes et régions. Pour en savoir plus sur la création de filesd'attente pour votre jeu, consultez Conception d'une file d'attente de session de jeu (p. 143).

Dans un client de jeu, les nouvelles sessions de jeu sont démarrées avec des files d'attente en utilisant desdemandes de placement. En savoir plus sur le placement de sessions de jeu dans Création de sessions dejeu (p. 55)

Pour créer une file d'attente, vous pouvez utiliser la console Amazon GameLift ou l'AWS Command LineInterface (interface de ligne de commande). Obtenez et installez l'outil AWS Command Line Interface..

Création d'une file d'attente (Console)Créez une file d'attente à partir de l'AWS Management Console.

Pour créer une file d'attente

1. Ouvrez la console Amazon GameLift à l'adresse https://console.aws.amazon.com/gamelift/ etchoisissez la région dans laquelle vous souhaitez créer votre file d'attente.

2. Dans le menu Amazon GameLift, choisissez Créer une file d'attente.3. Sur la page Create queue, renseignez la section Queue Details :

• Nom de la file d'attente – Créez un nom de file d'attente pertinent afin de pouvoir l'identifierdans une liste et dans les métriques. Les demandes de nouvelles session de jeu (à l'aide deStartGameSessionPlacement) doivent utiliser ce nom pour spécifier une file d'attente. Les espaceset caractères spéciaux ne sont pas autorisés.

• Expiration de la file d'attente – Spécifiez la durée pendant laquelle vous souhaitez qu'AmazonGameLift essaie de placer une nouvelle session de jeu avant d'arrêter. Amazon GameLift continue àrechercher des ressources disponibles sur une flotte jusqu'à ce que la demande expire.

4. Dans Player latency policies, définissez zéro, une ou plusieurs stratégies pour la file d'attente. Pourchaque demande de placement, Amazon GameLift minimise automatiquement la latence moyennepour tous les joueurs. Vous pouvez également créer des stratégies de latence pour définir une limitemaximale pour chaque joueur. Les stratégies de latence pour les joueurs ne sont évaluées que lorsqueles données de latence sont fournies dans la demande de placement. Vous pouvez choisir d'appliquerune limite tout au long du processus de placement, ou vous pouvez progressivement assouplir la limiteau fil du temps. Découvrez-en plus sur Conception des stratégies de latence du joueur (p. 146).

a. Pour ajouter une première stratégie, choisissez Add player latency policy. Entrez unevaleur maximale de latence pour les joueurs pour cette stratégie (la valeur par défaut est150 millisecondes). Comme indiqué dans le langage de la stratégie, cette première stratégiesera appliquée soit pour l'ensemble du processus de placement ou, si vous créez des stratégiessupplémentaires, pour le temps restant après expiration des autres stratégies. ——

Version149

Amazon GameLift Manuel du développeurCréation d'une file d'attente

b. Pour ajouter une autre stratégie de latence pour les joueurs, choisissez à nouveau Add playerlatency policy. Pour les stratégies supplémentaires, définissez la valeur maximale de latence pourles joueurs et une durée (en secondes) d'application. Les valeurs maximales de latence pour cesstratégies doivent être inférieures à la première stratégie.

Au fur et à mesure que vous ajoutez des stratégies, la console réorganise automatiquementl'ordre des stratégies en fonction de la valeur maximale de latence pour les joueurs, la latence laplus faible étant répertoriée en premier. C'est l'ordre dans lequel les stratégies sont appliquéespendant l'action de placement de session de jeu.

5. Dans Destinations, ajoutez une ou plusieurs destinations à la file d'attente. Une file d'attentepeut contenir les flottes de plusieurs régions avec des instances à la demande et des parcsd'instances Spot. Toutes les flottes de la file d'attente doivent avoir la même configuration de certificat(GENERATED ou DISABLED). La seule exigence est que toutes les flottes exécutent les mêmesbuilds de jeu qui sont compatibles avec les clients de jeu qui vont utiliser la file d'attente, comme lesflottes de plusieurs régions qui exécutent la même build de jeu. Les flottes et les alias doivent existerpour que vous puissiez les ajouter en tant que destinations.

a. Choisissez Add destination.b. Utilisez les colonnes pour spécifier la région et le type (flotte ou alias) pour votre destination. Dans

la liste des noms de flottes et d'alias obtenue, sélectionnez celui que vous souhaitez ajouter.c. Pour enregistrer la destination, choisissez la coche de couleur verte. Vous devez enregistrer

chaque destination avant d'en ajouter une autre, de modifier l'ordre par défaut, ou d'enregistrer lafile d'attente.

d. Si vous avez plusieurs destinations, définissez l'ordre par défaut en utilisant les flèches dansla colonne Priority (default). Cet ordre est utilisé par Amazon GameLift pour rechercher desressources disponibles pour placer une nouvelle session de jeu. (L'ordre par défaut est ignoré siune demande de placement de session de jeu inclut des données de latence pour les joueurs.)

6. Une fois que vous avez fini de configurer votre nouvelle file d'attente, choisissez Create queue. Votrenouvelle file d'attente est enregistrée et la page Queues affiche la nouvelle file d'attente, ainsi quetoutes les autres files d'attente existantes. Vous pouvez choisir une file d'attente à partir de cette pagepour afficher des informations détaillées, notamment des métriques de file d'attente. Vous pouvezmodifier la configuration d'une file d'attente à tout moment.

Création d'une file d'attente (AWS CLI)Vous pouvez utiliser AWS Command Line Interface (AWS CLI) pour créer une file d'attente. Obtenez etinstallez l'outil AWS Command Line Interface.

Pour créer une file d'attente

• Ouvrez une fenêtre de ligne de commande et utilisez la commande create-game-session-queue pour définir une nouvelle file d'attente. Pour plus d'informations, consultez la Référence descommandes d'AWS CLI.

L'exemple suivant crée une file d'attente pour placer de nouvelles sessions de jeu sur plusieurs flottesavant le délai d'expiration de cinq minutes. Les flottes sont répertoriées en tant que destinations etidentifiées par un ARN de flotte ou un ARN d'alias. Toutes les flottes et tous les alias doivent déjà exister.Amazon GameLift essaie de placer de nouvelles sessions de jeu sur les flottes dans l'ordre dans lequelelles sont répertoriées ici, sauf si l'ordre est remplacé par des demandes de placement de session de jeuindividuelles.

Note

Vous pouvez obtenir les valeurs de l'ARN de la flotte et de l'ARN de l'alias en appelant describe-fleet-attributes ou describe-alias avec l'ID de la flotte ou de l'alias. Pour plus d'informations sur les

Version150

Amazon GameLift Manuel du développeurCréation d'une file d'attente

formats des ARN (Amazon Resource Name), consultez Noms ARN (Amazon Resource Name) etespaces de noms du service 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

Version 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 demande create-game-session-queue aboutit, Amazon GameLift renvoie un objetGameSessionQueue avec la nouvelle configuration de la file d'attente. Vous pouvez désormais envoyerdes demandes à la file d'attente en utilisant StartGameSessionPlacement.

Pour créer une file d'attente avec les stratégies de latence pour les joueurs

• Ouvrez une fenêtre de ligne de commande et utilisez la commande create-game-session-queue pour définir une nouvelle file d'attente. Pour plus d'informations, consultez la Référence descommandes d'AWS CLI.

L'exemple suivant crée une file d'attente avec un délai de 10 minutes, trois destinations et un ensemble destratégies de latence pour les joueurs. Dans cet exemple, la première stratégie de latence pour les joueursest en vigueur pendant les deux premières minutes, la deuxième pendant les troisième et quatrièmeminutes, et la troisième pendant six minutes jusqu'à ce que la demande de placement ait dépassé le délai.

$ 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"

Version 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

Version151

Amazon GameLift Manuel du développeurAfficher vos files d'attente

"MaximumIndividualPlayerLatencyMilliseconds=50,PolicyDurationSeconds=120" "MaximumIndividualPlayerLatencyMilliseconds=100,PolicyDurationSeconds=120" "MaximumIndividualPlayerLatencyMilliseconds=150"

Si la demande create-game-session-queue aboutit, Amazon GameLift renvoie un objetGameSessionQueue avec la nouvelle configuration de la file d'attente.

Afficher vos files d'attenteVous pouvez afficher des informations sur toutes les files d'attente (p. 143) de placement de sessionde jeu existantes. Seules sont affichées les files d'attente qui ont été créées dans la région sélectionnée.Depuis la page Queues, vous pouvez créer une file d'attente, supprimer les files d'attente existantes ououvrir une page d'informations détaillées pour une file d'attente sélectionnée. La page de détails d'une filed'attente contient la configuration de la file d'attente et les données des métriques. Vous pouvez égalementmodifier ou supprimer la file d'attente.

Pour afficher la page Queues

1. Choisissez Files d'attente dans le menu de la console Amazon GameLift.

La page Queues affiche les informations récapitulatives suivantes pour chaque file d'attente :

• Nom de la file d'attente – Nom attribué à la file d'attente. Les demandes de nouvelles sessions dejeu utilisent ce nom pour spécifier une file d'attente.

• Expiration de la file d'attente – Durée maximale, en secondes, pendant laquelle une demande deplacement de session de jeu reste dans la file d'attente avant d'expirer.

• Destinations dans la file d'attente – Nombre de flottes répertoriées dans la configuration de la filed'attente. Les nouvelles sessions de jeu peuvent être placées sur n'importe quelle flotte de la filed'attente.

2. Pour afficher les détails d'une file d'attente, y compris les métriques, choisissez le nom de la filed'attente. Pour plus d'informations sur la page des détails des files d'attente, consultez Affichage desdétails des files d'attente (p. 152).

Affichage des détails des files d'attenteVous pouvez accéder aux informations détaillées relatives à n'importe quelle file d'attente, notamment surla configuration et les métriques de la file d'attente. Pour ouvrir une page de détails Queue, accédez à lapage principale Queues et choisissez un nom de file d'attente.

La page des détails d'une file d'attente affiche un tableau récapitulatif et des onglets comportant desinformations supplémentaires. Sur cette page, vous pouvez effectuer les opérations suivantes :

• Mettre à jour la configuration de la file d'attente, la liste des destinations et les stratégies de latence pourles joueurs. Choisissez Actions, Edit queue.

• Supprimer une file d'attente. Après la suppression d'une file d'attente, toutes les demandes de nouvellessessions de jeu faisant référence au nom de cette file d'attente échouent. (Veuillez noter que les filesd'attente supprimées peuvent être restaurées en créant simplement une file d'attente avec le nom de lafile d'attente supprimée.) Choisissez Actions, Delete queue.

RécapitulatifLe tableau récapitulatif comprend les informations suivantes :

• Nom de la file d'attente – Nom attribué à la file d'attente. Les demandes de nouvelles sessions de jeuutilisent ce nom pour spécifier une file d'attente.

Version152

Amazon GameLift Manuel du développeurAfficher vos files d'attente

• Expiration de la file d'attente – Durée maximale, en secondes, pendant laquelle une demande deplacement de session de jeu reste dans la file d'attente avant d'expirer.

• Destinations dans la file d'attente – Nombre de flottes répertoriées dans la configuration de la filed'attente. Les nouvelles sessions de jeu peuvent être placées sur n'importe quelle flotte de la filed'attente.

DestinationsL'onglet Destinations affiche toutes les flottes ou tous les alias répertoriés pour la file d'attente. Les flottessont identifiées par un ARN de flotte ou un ARN d'alias, qui spécifie l'ID de la flotte ou de l'alias et la région.

Quand Amazon GameLift recherche les destinations pour que les ressources disponibles puissenthéberger une nouvelle session de jeu, il effectue ses recherches dans l'ordre répertorié ici. Tant qu'il ya des capacités sur la première destination listée, les nouvelles sessions de jeu y sont placées. Il s'agitde l'ordre par défaut pour les destinations. Vous pouvez faire en sorte que les demandes de placementde session de jeu remplacent l'ordre par défaut en fournissant les données de latence du joueur. Cesdonnées indiquent à Amazon GameLift de rechercher une destination disponible avec la plus faible latencemoyenne.

Pour ajouter, modifier ou supprimer des destinations, choisissez Actions, Edit queue.

Stratégies de latence pour les joueursL'onglet Player latency policies affiche toutes les stratégies qui ont été définies pour la file d'attente. Lesstratégies sont répertoriées dans l'ordre où elles sont appliquées pendant une action de placement desession de jeu.

Pour ajouter, modifier ou supprimer des stratégies de latence pour les joueurs, choisissez Actions, Editqueue.

Métriques de file d'attenteL'onglet Metrics affiche une représentation graphique des métriques d'une file d'attente au fil du temps.

Les métriques de file d'attente incluent une quantité d'informations décrivant les activités de placement surl'ensemble de la file d'attente, ainsi que les placements, découpés par région. Les données spécifiques àune région sont utiles pour suivre où sont hébergés vos jeux. Avec les files d'attente qui utilisent FleetIQqui priorisent les placements afin de minimiser la latence et les coûts d'hébergement, les métriquesde placement régionales peuvent aider à détecter des problèmes liés à la conception globale de la filed'attente.

Les métriques de file d'attente sont également disponibles dans Amazon CloudWatch. Vous pouvezconsulter les descriptions de toutes les métriques sur Métriques GameLift pour les files d'attente (p. 207).

Pour afficher les informations de métriques dans le graphique

1. Cliquez sur un ou plusieurs noms de métriques répertoriés à gauche de la zone de graphique. Lesnoms des métriques indiqués en noir sont affichés dans le graphique, tandis que ceux en gris sontdésactivés. Utilisez le code couleur pour identifier les lignes de graphique qui correspondent à unemétrique sélectionnée.

2. Utilisez les filtres suivants, affichés au-dessus de la zone de graphique, pour modifier le moded'affichage des données des métriques :

• Données et Période – Propose deux options pour sélectionner une plage de dates :• Utilisez Relative pour sélectionner une période relative à l'heure en cours, par exemple Last hour,

Last day, Last week.• Utilisez Absolute pour indiquer une période avec une date/heure de début et de fin arbitraire.

• Granularité – Sélectionnez une durée pour l'agrégation des points de données.

Version153

Amazon GameLift Manuel du développeurConfiguration de matchmakers FlexMatch

• Taux de rafraîchissement – Sélectionnez la fréquence de mise à jour de l'affichage du graphique.Vous pouvez actualiser le graphique à tout moment en cliquant sur le bouton d'actualisation dans lecoin supérieur droit du graphique.

• Fuseau horaire – Sélectionnez le format d'heure à utiliser dans l'affichage du graphique : UTC(temps universel coordonné) ou Browser time (Heure du navigateur) (heure locale).

• Afficher les points – Permet d'afficher les points de données discrets sous la forme de cercles oud'afficher les lignes uniquement.

Configuration de matchmakers Amazon GameLiftFlexMatch

Un matchmaker FlexMatch effectue la tache de créer une mise en relation pour un jeu. Il gère le pool desdemandes de mise en relation reçues, forme les équipes d'une mise en relation, traite et sélectionne lesjoueurs pour trouver les meilleurs groupes de joueurs possibles et lance le processus de placement et dedémarrage d'une session de jeu pour la mise en relation. Cette rubrique décrit les principaux aspects d'unmatchmaker et explique comment configurer un matchmaker personnalisé pour votre jeu.

Pour une description détaillée de la façon dont un matchmaker FlexMatch traite les demandes de mise enrelation qu'il reçoit, consultez Processus de mise en relation (p. 16).

Rubriques• Concevoir un FlexMatch matchmaker (p. 154)• Créer une configuration de mise en relation (p. 156)• Créer un ensemble FlexMatch de règles (p. 158)• Configuration de la notification FlexMatch d'événement (p. 186)

Concevoir un FlexMatch matchmakerConfigurations du matchmakerAu minimum, un matchmaker a besoin de trois éléments :

• L'ensemble de règles détermine la taille et le périmètre des équipes pour une mise en relation etdéfinit un ensemble de règles à utiliser lors de l'évaluation des joueurs d'une mise en relation. Chaquematchmaker est configuré pour utiliser un seul ensemble de règles. Pour plus d'informations surla création d'ensembles de règles, consultez Créer un ensemble FlexMatch de règles (p. 158) etExemples FlexMatch d'ensembles de règles (p. 169).

• La file d'attente de sessions de jeu détermine où les rencontres créées par ce matchmaker seronthébergées. Le matchmaker utilise la file d'attente pour rechercher les ressources disponibles et placerune session de jeu pour la mise en relation. Une file d'attente spécifie les régions à utiliser lorsque vousplacez une session de jeu. Pour plus d'informations sur la création de files d'attente, consultez Créationd'une file d'attente (p. 149).

• Le délai d'attente détermine la durée pendant laquelle des demandes de mise en relation peuvent resterdans le pool de demandes et être évaluée pour des mises en relation potentielles. Une fois qu'unedemande a dépassé le délai, elle a échoué à créer une mise en relation et elle supprimée du pool.

En plus de ces exigences minimales, vous pouvez configurer votre matchmaker avec les optionssupplémentaires suivantes.

Acceptation des joueurs

Version154

Amazon GameLift Manuel du développeurConcevoir un matchmaker

Vous pouvez configurer un matchmaker pour exiger que tous les joueurs sélectionnés pour une mise enrelation acceptent la participation. Si l'acceptation est obligatoire, tous les joueurs doivent avoir la possibilitéd'accepter ou de rejeter une mise en relation proposée. Une mise en relation doit recevoir les acceptationsde tous les joueurs avant d'être effective. Si un joueur refuse ou ne parvient pas à accepter une mise enrelation, la mise en relation proposée est ignorée. Les demandes de mise en relation sont gérées commesuit : les demandes où tous les joueurs ont accepté la mise en relation sont renvoyées dans le pool de miseen relation pour la poursuite du traitement ; les demandes dans lesquelles au moins un joueur a refuséla mise en relation ou n'a pas pu répondre échouent et ne sont plus traitées. L'acceptation des joueursnécessite une limite de temps, que vous pouvez définir ; tous les joueurs doivent accepter une mise enrelation proposée dans les délais pour que la mise en relation se poursuive.

Notification de mise en relation

Cette fonction envoie tous les événements liés à une activité de mise en relation sur une rubrique AmazonSimple Notification Service (SNS) définie. Dans la mesure où les demandes de mise en relation sontasynchrones, tous les jeux doivent avoir un moyen de suivre l'état des demandes de mise en relation, etla configuration des notifications est simple et efficace. Pour plus d'options sur le suivi des demandes,consultez Ajouter FlexMatch à un client de jeu (p. 79). Pour utiliser les notifications, vous devez d'abordconfigurer une rubrique SNS, puis fournir l'ARN de la rubrique en tant que cible de notification dans laconfiguration de mise en relation. Pour plus d'informations sur la configuration des notifications, consultezConfiguration de la notification FlexMatch d'événement (p. 186).

Mode de remplissage

La fonction de remplissage FlexMatch est utile pour remplir les emplacements dédiés aux joueurs videsavec de nouveaux joueurs qui se correspondent bien tout au long de la durée de vie de la session dejeu. Lors du traitement des demandes de remplissage, FlexMatch utilise le même matchmaker et lemême processus pour trouver de nouveaux joueurs que ceux utilisés pour choisir les joueurs initiaux.En définissant le mode de remplissage dans la configuration de la mise en relation, vous pouvez choisird'utiliser un remplissage automatique ou de gérer les demandes de remplissage manuellement. Pour ensavoir plus sur le remplissage automatique, voir Renvoi de jeux existants avecFlexMatch (p. 85).

Lorsque le mode de remplissage automatique est configuré, GameLift déclenche une nouvelle demandede remplissage chaque fois qu'une session de jeu dispose d'un emplacement de joueur ouvert. GameLiftcommence la génération des demandes de remplissage pour toutes les sessions de jeu qui ont une placevide dès que leur démarrage sur un serveur de jeux. Le remplissage automatique se poursuit tant qu'iln'est pas explicitement désactivé pour une session de jeu. Si votre matchmaker utilise un ensemble derègles qui définit les parties à beaucoup de joueurs (plus de 40 personnes), les demandes de remplissagegénérées automatiquement bénéficient d'une priorité plus élevée. Autrement dit, au fur et à mesure que denouveaux joueurs arrivent et demandent une place dans le jeu, ils sont plus susceptibles d'être placés dansun jeu existant que dans un nouveau jeu.

Définissez le mode de remplissage manuel si vous ne souhaitez pas remplir automatiquement vos jeux ousi vous souhaitez déclencher manuellement les demandes de remplissage de vos jeux. Le remplissagemanuel vous offre la flexibilité dont vous avez besoin pour déterminer quand déclencher une demandede remplissage. Par exemple, vous pouvez choisir de ne pas ajouter de nouveaux joueurs au cours decertaines phases du jeu ou uniquement lorsque certaines conditions sont réunies. Vous pouvez déclenchermanuellement les demandes de remplissage à partir de votre serveur de jeux (ce qui est préférable, car leserveur de jeux dispose d’informations en temps réel sur le nombre de joueurs) ou de votre client de jeux.

Si vous implémentez une solution de remplissage, vous souhaiterez peut-être configurer la façon dontles requêtes de remplissage sont hiérarchisées par rapport aux nouvelles requêtes de mise en relation.Ceci est effectué dans votre ensemble de règles de mise en relation en personnalisant la priorité deremplissage. Pour en savoir plus, consultez Personnalisation de l'algorithme de correspondance (p. 159).

Propriétés du jeu

Lorsque vous demandez une nouvelle session de jeu, vous pouvez transmettre des informationssupplémentaires à votre serveur de jeux sur le type de session de jeu à créer. Les propriétés de jeupeuvent être fournies avec n'importe quel type de demande de session de jeu, que ce soit avec une

Version155

Amazon GameLift Manuel du développeurCréer une configuration de mise en relation

demande de placement ou une demande de mise en relation. Avec l'activité de mise en relation, lespropriétés de jeu sont incluses dans la configuration du matchmaker. Toutes les sessions de jeu créées àl'aide d'un matchmaker utilisent les mêmes propriétés de jeu. Si vous avez besoin de varier les propriétésde jeu, créez des matchmakers distincts et envoyez les demandes de mise en relation au matchmakeravec les propriétés de jeu appropriées.

Emplacements de joueur réservés

Vous pouvez définir certains emplacements de joueur comme étant réservés et remplis ultérieurement.Pour cela, vous devez configurer la propriété « additional player count » d'une configuration de mise enrelation.

Données d'événement personnalisées

Utilisez cette propriété pour inclure un ensemble d'informations personnalisées dans tous les événementsliés à l'activité de mise en relation et destinés au matchmaker. Cette fonction peut être utile pour le suivid'une activité spécifique à votre jeu, y compris le suivi des performances de vos matchmakers.

Créer une configuration de mise en relationPour configurer un matchmaker FlexMatch, vous créez une configuration de mise en relation. Utilisez laconsole Amazon GameLift ou l'AWS Command Line Interface (AWS CLI). Pour plus d'informations sur laconfiguration d'un matchmaker, consultez the section called “Concevoir un matchmaker” (p. 154).

Choix d'une région pour le matchmaker

Un matchmaker est hébergé dans la région où sa configuration est créée. Prenez bien en considération lefait que l'emplacement d'un matchmaker peut affecter ses performances, ainsi que l'expérience des joueursconcernés. Nous vous recommandons de placer un matchmaker dans une région proche des clients oudu service client qui effectue les demandes de mise en relation. En tant que bonne pratique, nous vousrecommandons également de placer le matchmaker et la file d'attente qu'il utilise dans la même région.Cela permet de réduire la latence des communication entre le matchmaker et la file d'attente.

Créer un matchmaker

Avant de pouvoir configuré une mise en relation, vous devez créer l'ensemble de règles et la file d'attenteque vous souhaitez utiliser avec le matchmaker.

Console

1. Ouvrez la console Amazon GameLift à l'adresse https://console.aws.amazon.com/gamelift/home.2. Basculez vers la région où vous souhaitez placer votre matchmaker.3. Dans le menu principal, choisissez Create matchmaking configuration. Complétez les détails de la

configuration de mise en relation.

• Nom – Créez un nom de matchmaker pertinent afin de pouvoir l'identifier facilement dans uneliste et dans les métriques. Le nom d'un matchmaker doit être unique au sein d'une région. Lesdemandes de mise en relation identifient le matchmaker à utiliser à l'aide de son nom et de sarégion.

• Description – (facultatif) Ajoutez une description du matchmaker. La description est utilisée àtitre d'identification uniquement ; elle n'est pas utilisée dans le processus de mise en relation.

• File d'attente – Choisissez la file d'attente de sessions de jeu à utiliser avec ce matchmaker.Pour trouver la file d'attente, vous devez d'abord choisir la région où la file d'attente estconfigurée. Ensuite, choisissez la file d'attente de votre choix dans la liste des files d'attentedisponibles dans cette région.

• Expiration de la demande – Entrez la durée maximale autorisée, en secondes, pour qu'unmatchmaker effectue une mise en relation pour chaque demande. Les demandes de mise enrelation qui dépassent cette durée sont résiliées.

Version156

Amazon GameLift Manuel du développeurCréer une configuration de mise en relation

• Acceptation requise – (facultatif) Indiquez si vous souhaitez exiger que chaque joueurd'une mise en relation proposée accepte activement sa participation. Si vous répondez parl'affirmative, indiquez la durée pendant laquelle vous voulez que le matchmaker attende lesacceptations des joueurs avant d'annuler la mise en relation.

• Nom de l'ensemble de règles – Choisissez l'ensemble de règles à utiliser avec le matchmaker.La liste contient tous les ensembles de règles qui ont été créés dans la région en cours.

• Mode de remplissage automatique – Spécifiez une méthode pour gérer le remplissagedes parties. Sélectionnez « Automatique » pour activer la fonctionnalité de remplissageautomatique. Choisissez « Manuel » si vous gérez vous-même les demandes de remplissagedans votre serveur ou client de jeux, ou si vous ne souhaitez pas remplir automatiquement lesjeux.

• Cible de notification – (facultatif) Saisissez l'ARN d'une rubrique SNS pour recevoir lesnotifications d'événement de mise en relation. Si vous n'avez pas encore défini cetteinformation, vous pouvez l'ajouter ultérieurement en modifiant la configuration de mise enrelation. Consultez Configuration de la notification FlexMatch d'événement (p. 186).

• Joueurs supplémentaires – (facultatif) Spécifiez le nombre d'emplacements de joueur quidoivent rester vides lors de chaque nouveau match. Ces emplacements pourront être remplis àl'avenir par des joueurs.

• Données d'événement personnalisées – (facultatif) Spécifiez les données que vous voulezassocier à ce matchmaker dans les messages d'événement. Ces données sont incluses danschaque événement associé au matchmaker.

4. Une fois que vous avez fini de configurer un matchmaker, cliquez sur Create. Si la créationréussit, le matchmaker est immédiatement prêt à accepter les demandes de mise en relation.

AWS CLI

Pour créer une configuration de mise en relation avec l'AWS CLI, ouvrez une fenêtre de ligne decommande et utilisez la commande create-matchmaking-configuration pour définir unnouveau matchmaker. Consultez la documentation complète sur cette commande dans la Référencedes commandes d'AWS CLI. Obtenez et installez l'outil AWS Command Line Interface..

Cet exemple montre comment créer une configuration de mise en relation qui nécessite l'acceptationdes joueurs et utilise les notifications pour suivre l'état des demandes de mise en relation. Il réserveégalement deux emplacements pour des joueurs supplémentaires à ajouter ultérieurement.

$ 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"--backfill-mode "AUTOMATIC"--notification-target "arn:aws:sns:us-west-2:111122223333:My_Matchmaking_SNS_Topic"--additional-player-count "2"--game-session-data "key=map,value=winter444"

Version 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" --backfill-mode "AUTOMATIC" --

Version157

Amazon GameLift Manuel du développeurCréer un ensemble de règles

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 demande de création de la configuration de mise en relation aboutit, Amazon GameLift renvoie unMatchmakingConfiguration objet avec les paramètres que vous avez demandés pour le matchmaker.Le nouveau matchmaker est immédiatement prêt à accepter les demandes de mise en relation.

Créer un ensemble FlexMatch de règlesChaque matchmaker FlexMatch doit disposer d'un ensemble de règles. L'ensemble de règles détermine lesdeux éléments clés d'une mise en relation : la structure et la taille de l'équipe, et le mode de regroupementdes joueurs pour la meilleure expérience possible.

Par exemple, un ensemble de règles peut décrire une correspondance comme suit : Créez une miseen relation avec deux équipes de cinq joueurs chacune, l'une étant les défenseurs et l'autre l'équipe quiest à l'origine de l'envahissement. Une équipe peut avoir des joueurs novices et expérimentés, mais leniveau de compétence moyen des deux équipes doit être à moins de 10 points l'un de l'autre. Si aucunecorrespondance n'est trouvée après 30 secondes, assouplissez progressivement les exigences decompétence.

Les rubriques de cette section décrivent comment concevoir et créer un ensemble de règles de mise enrelation. Lors de la création d'un ensemble de règles, vous pouvez utiliser la console Amazon GameLift oul'interface de ligne de commande AWS.

Rubriques

• Concevoir un ensemble FlexMatch de règles (p. 158)• Créer des ensembles de règles de mise en relation (p. 167)• Exemples FlexMatch d'ensembles de règles (p. 169)• ensemble FlexMatch de règles schéma (p. 324)• Langage FlexMatch des règles (p. 331)

Concevoir un ensemble FlexMatch de règlesÀ la base, un ensemble de règles de mise en relation permet de faire deux choses : déterminer la structureet la taille de l'équipe d'une partie et indiquer au matchmaker comment évaluer les joueurs afin de trouverla meilleure partie possible. Toutefois, les possibilités sont multiples. Par exemple, un ensemble de règlespermet également de gérer les situations de mise en relation suivantes :

• Optimisez l'algorithme correspondant pour votre jeu.• Déclencher un traitement spécial pour les parties à grande échelle (plus de 40 joueurs).• Appliquez les exigences minimales de latence du joueur pour protéger la qualité du gameplay.• Assouplissez progressivement les exigences de l'équipe ou les règles de mise en relation si aucune

partie ne peut être effectuée.• Définir le traitement spécial des demandes de mise en relation impliquant plusieurs joueurs (agrégation

de partie).

Cette rubrique aborde la structure élémentaire d'un ensemble de règles et la façon de les utiliser pourles parties dont le nombre de participants ne dépasse pas 40 joueurs. Les parties impliquant plusde 40 joueurs nécessitent une autre structure, car FlexMatch utilise un algorithme rationalisé pourmettre rapidement en relation les vastes groupes de joueurs. Pour en savoir plus sur la création departies à grande échelle, voir Concevoir un ensemble de règles FlexMatch pour une partie à grandeéchelle (p. 164).

Version158

Amazon GameLift Manuel du développeurCréer un ensemble de règles

Rubriques connexes

• Créer des ensembles de règles de mise en relation (p. 167)• Exemples FlexMatch d'ensembles de règles (p. 169)• Langage FlexMatch des règles (p. 331)• ensemble FlexMatch de règles schéma (p. 324)

Définir les composants d'un ensemble de règles

Tous les ensembles de règles contiennent une partie ou la totalité des composants, comme décrit dans leschéma général de l'ensemble de règles dans ensemble FlexMatch de règles schéma (p. 324) . Cetterubrique couvre les problèmes de conception pour chaque composant d'ensemble de règles :

• Décrire l'ensemble de règles (p. 159)• Personnalisation de l'algorithme de correspondance (p. 159)• Déclaration des attributs de joueur (p. 162)• Définir les équipes de mise en relation (p. 163)• Définir des règles pour la mise en relation des joueurs (p. 163)• Autoriser les exigences à assouplir au fil du temps (p. 164)

Vous avez besoin d'un ensemble de règles pour créer des rencontres comprenant plus de 40joueurs ? Découvrez comment Concevoir un ensemble de règles FlexMatch pour une partie à grandeéchelle (p. 164).

Décrire l'ensemble de règles

Fournissez les détails relatifs à l'ensemble de règles.

• name (facultatif) – Étiquette descriptive au sein de la syntaxe de l'ensemble de règles, mais qui n'estpas utilisée par Amazon GameLift de façon significative. Ne pas confondre cette valeur avec le nom del'ensemble de règles, qui est défini, ainsi que la syntaxe de l'ensemble de règles, lorsque vous créez unensemble de règles.

• ruleLanguageVersion(obligatoire) – Il s'agit de la version du langage d'expression des propriétés utiliséepour créer FlexMatch des règles. Cette valeur doit être égale à 1.0.

Personnalisation de l'algorithme de correspondance

Vous avez la possibilité de modifier certains éléments de l'algorithme de correspondance par défaut.Par défaut, l'algorithme par défaut est optimisé pour la plupart des jeux afin de traiter rapidement etefficacement les demandes de mise en relation, ce qui permet aux joueurs d'obtenir des mises en relationacceptables avec un temps d'attente minimal. Vous pouvez personnaliser l'algorithme et ajuster lespriorités de correspondance pour mieux répondre aux besoins de votre jeu.

Le processus de mise en FlexMatch relation par défaut est le suivant :

1. Tous les tickets de mise en relation ouverts et les tickets de remplissage sont placés dans un groupe deticket.

2. Les tickets sont regroupés de façon aléatoire en un ou plusieurs lots pour la correspondance.Plusieurs lots sont formés uniquement lorsque le groupe de ticket devient trop volumineux pour unecorrespondance optimale.

3. Chaque lot est trié par âge de ticket.4. A partir du ticket le plus ancien, tous les tickets d'un lot sont évalués pour les correspondances

acceptables.

Version159

Amazon GameLift Manuel du développeurCréer un ensemble de règles

Les personnalisations suggérées suivantes ont un impact sur les différentes étapes du processus de miseen relation. Pour personnaliser l'algorithme de correspondance, ajoutez un algorithm composant à votreschéma d'ensemble de règles. Consultez ensemble FlexMatch de règles schéma (p. 324) pour obtenirles informations de référence complètes.

Ajouter un tri préalable par lots

Vous pouvez configurer FlexMatch pour trier le groupe de ticket avant de former des lots. Ce type depersonnalisation est plus efficace avec les jeux qui ont tendance à avoir de très grands groupes de tickets.Le tri pré-lot peut être utilisé pour aider à accélérer le processus de mise en relation. Il a égalementtendance à former des mises en relation avec plus d'uniformité des joueurs dans certaines caractéristiques.

Les méthodes de tri par lots sont définies dans la propriété d'algorithmebatchingPreference. Leparamètre par défaut est « random », qui indique qu'aucun tri préalable ne se produit.

Les options de personnalisation du tri pré-lot sont les suivantes :

• Triez par attributs de joueur. Fournissez une liste d'attributs de joueur pour trier au préalable le groupede tickets. Cette personnalisation entraîne FlexMatch la création de lots avec plus d'uniformité dans lesattributs triés. Par exemple, si vous triez au préalable le groupe de tickets par compétence de joueur, lestickets ayant des niveaux de compétence similaires ont tendance à être regroupés ensemble. Si votreensemble de règles contient également des règles de mise en relation basées sur la compétence desjoueurs, le tri pré-lots peut améliorer considérablement l'efficacité de la mise en relation.

Pour activer cette personnalisation, définissez la propriété de lbatchingPreference'algorithme sur« sorted » et définissez la propriété sur la liste des attributs de joueur.sortByAttributes Chaqueattribut de la liste doit être déclaré dans le playerAttributes composant de l'ensemble de règles.

Dans l'exemple suivant, FlexMatch trie le groupe de ticket en fonction de la relation de jeu préféréedes joueurs, puis par compétence de joueur. Les lots résultants sont plus susceptibles de contenir desjoueurs aux compétences similaires qui souhaitent utiliser la même carte.

"algorithm": { "batchingPreference": "sorted", "sortByAttributes": ["map", "player_skill"], "strategy": "exhaustiveSearch"},

• Triez par latence. Choisissez entre hiérarchiser l'un des éléments suivants : (1) mettre les joueursdans les parties avec la plus faible latence disponible, ou (2) obtenir rapidement les joueurs dans lesparties avec une latence acceptable. Cette personnalisation convient avec des ensembles de règlespour la formation de parties à grande échelle (plus de 40 joueurs) ; la propriété strategy d'algorithmedoit être définie sur « balanced », ce qui limite considérablement les types d'instructions de règledisponibles. Veuillez consulter Concevoir un ensemble de règles FlexMatch pour une partie à grandeéchelle (p. 164).

Cette personnalisation entraîne FlexMatch le tri préalable des tickets en fonction des données de latencesignalées de l'une des manières suivantes :• Amenez les joueurs dans les régions où la latence est la plus faible. Le groupe de ticket est pré-trié par

les régions où les joueurs signalent leurs valeurs de latence les plus faibles. Cela entraîne FlexMatchdes tickets par lots qui signalent une faible latence dans les mêmes régions, ce qui a tendance àmettre en relation les joueurs dans leurs régions les plus rapides et dans de meilleures expériencesde jeu globalement. Elle diminue également le nombre de tickets dans chaque lot, de sorte que lesparties peuvent prendre plus de temps. Pour activer cette personnalisation, définissez la propriété delbatchingPreference'algorithme sur la valeur « fastestRegion », comme illustré dans l'exemplesuivant.

"algorithm": {

Version160

Amazon GameLift Manuel du développeurCréer un ensemble de règles

"batchingPreference": "fastestRegion", "strategy": "balanced"},

• Obtenir rapidement les joueurs pour les rencontres de latence acceptables. L'interrogation destickets est pré-triée par régions où les joueurs signalent toute valeur de latence acceptable. Cetteméthode a tendance à former moins de lots, chacun contenant un grand nombre de tickets ayantune latence acceptable dans les mêmes régions. Avec plus de tickets dans chaque lot, la recherchede suffisamment de correspondances acceptables a tendance à être plus facile et plus rapide.Pour activer cette personnalisation, définissez la propriété batchingPreference sur la valeur «largestPopulation », comme illustré dans l'exemple suivant. (Cette méthode est le comportement pardéfaut pour les ensembles de règles qui utilisent la stratégie équilibrée.)

"algorithm": { "batchingPreference": "largestPopulation", "strategy": "balanced"},

Hiérarchisation des tickets de remplissage

Si votre jeu implémente le remplissage automatique ou le remplissage manuel, vous pouvez personnaliserla façon dont FlexMatch traite les tickets de mise en relation en fonction du type de demande (nouvelledemande de nouvelle mise en relation ou de remplissage). Par défaut, les deux types de demandessont traités de manière égale. Cette personnalisation conduit FlexMatch à essayer de remplir les ticketsde remplissage en premier ou uniquement lorsque de nouvelles correspondances ne peuvent pasêtre effectuées. Elle peut également avoir un impact sur l'utilisation des ressources d'hébergement –en intégrant les joueurs dans un nombre réduit de sessions de jeu ou en créant des sessions de jeupartiellement remplies.

La hiérarchisation du remplissage affecte la façon dont les tickets sont gérés une fois qu'ils ont été traitéspar lots ; cela n'affecte pas le processus de traitement par lots des tickets. Vous pouvez implémenterle tri préalable par lots et la hiérarchisation du remplissage si nécessaire. Utilisez la hiérarchisation duremplissage uniquement avec les ensembles de règles qui utilisent la stratégie de recherche exhaustive.

Pour modifier la hiérarchisation des tickets de remplissage, définissez la propriété backfillPrioritycomme suit :

• Faites correspondre les tickets de remplissage en premier. Cette option vous invite FlexMatch à évalueret à essayer de compléter les tickets de remplissage avant de créer de nouvelles correspondances. Celasignifie que les joueurs entrants ont plus de chance d'être placés dans un jeu existant. Définissez lapropriété backfillPriority sur « high ».

Si votre jeu utilise le remplissage automatique, activez cette personnalisation en tant que bonne pratique.Le remplissage automatique est le plus souvent utilisé dans les jeux avec de courtes durées de sessionde jeu et un délai d'attente élevé des joueurs. Le remplissage automatique aide ces jeux à formerrapidement des rencontres viables minimales et à les faire démarrer, même lorsque FlexMatch chercheplusieurs joueurs pour remplir des emplacements ouverts. Essayez d'abord de remplir les tickets deremplissage pour optimiser cette approche.

"algorithm": { "backfillPriority": "high", "strategy": "exhaustiveSearch"},

• Correspondance des tickets de remplissage. Cette option vous invite FlexMatch à ignorer les ticketsde remplissage jusqu'à ce que tous les autres tickets aient été évalués. Cela signifie que les joueursentrants sont uniquement renvoyés dans les jeux existants lorsqu'ils ne peuvent pas être mis en relationavec de nouveaux jeux. Définissez la propriété backfillPriority sur « low ».

Version161

Amazon GameLift Manuel du développeurCréer un ensemble de règles

Cette option est utile lorsque vous souhaitez utiliser le remplissage en tant qu'option de dernièrechancepour intégrer des joueurs à un jeu, par exemple lorsqu'il y a trop peu de joueurs pour former une nouvellerencontre. La déspriorisation des tickets de remplissage ne doit jamais être utilisée avec le remplissageautomatique.

"algorithm": { "backfillPriority": "low", "strategy": "exhaustiveSearch"},

Privilégier les anciens tickets avec des extensions

Permet de personnaliser la façon dont FlexMatch applique les règles d'extension, ce qui assouplit lescritères de mise en relation lorsque les mises en relation sont difficiles à effectuer. GameLift applique lesrègles d'extension lorsque les billets d'une mise en relation partiellement terminée atteignent un certainâge. Les horodatages de création des tickets déterminent quand les règles sont appliquées ; par défaut,FlexMatch suit l'horodatage du ticket le plus récemment correspondant.

Pour modifier le moment où les règles d'extension sont appliquées, définissez la propriétéexpansionAgeSelection comme suit :

• Développer en fonction des tickets les plus récents. Cette option applique les règles d'extension enfonction du ticket le plus récent ajouté à la mise en relation potentielle. Chaque fois qu'un nouveau ticketest associé, l'horloge est réinitialisée. Avec cette option, il est plus difficile d'appliquer une extension ; lesparties résultantes ont tendance à avoir une meilleure qualité, mais le temps d'attente pour les joueurspeut être plus long, et les demandes de partie peuvent expirer avant d'être terminées. Définissez lapropriété expansionAgeSelection sur « latest » (il s'agit de la valeur par défaut).

• Développer en fonction des tickets les plus anciens. Cette option applique des règles d'extensionbasées sur le ticket le plus ancien de la mise en relation potentielle, qui est généralement (mais pastoujours) le premier ticket ajouté à la mise en relation. Avec cette option, les extensions ont tendanceà être appliquées plus rapidement, ce qui améliore les temps d'attente pour les premiers joueurs misen relation, mais réduit également la qualité de la mise en relation pour tous les joueurs. Définissez lapropriété sur « plus ancienne ».expansionAgeSelection

"algorithm": { "expansionAgeSelection": "oldest", "strategy": "exhaustiveSearch"},

Déclaration des attributs de joueur

Les règles permettent de choisir les joueurs pour les parties en fonction des caractéristiques de chaquejoueur. Si vous créez des règles qui reposent sur les attributs des joueurs, ceux-ci doivent être déclarésdans cette section. Les valeurs des attributs de joueur déclarés doivent être incluses dans chaquedemande de mise en relation envoyée à un matchmaker à l'aide de cet ensemble de règles.

Vous pouvez également transmettre certains attributs de joueur à la session de jeu, même si l'ensemblede règles ne les utilise pas lors de l'évaluation des joueurs. Par exemple, vous pouvez transmettre lepersonnage choisi par le joueur. Pour ce faire, déclarez vos attributs de joueur ici et incluez les valeursd'attribut pour chaque joueur dans vos demandes de mise en relation.

Lorsque vous déclarez un attribut de joueur, incluez les informations suivantes :

• name (obligatoire) – Cette valeur doit être spécifique à l'ensemble de règles.

Version162

Amazon GameLift Manuel du développeurCréer un ensemble de règles

• type (obligatoire) – Type de données de la valeur de l'attribut. Les types de données valides sontnumber, string ou string map.

• default (facultatif) – Entrez une valeur par défaut à utiliser si aucune valeur n'est fournie pour un joueur.Si aucune valeur par défaut n'est déclarée et qu'un joueur ne fournit pas de valeur, le joueur ne peut pasêtre associé à la mise en relation.

Définir les équipes de mise en relation

Décrivez la structure et la taille des équipes pour une partie. Chaque partie doit être associée à au moinsune équipe. Le nombre total d'équipes n'est pas limité. Vos équipes peuvent avoir le même nombre dejoueurs ou être asymétriques. Par exemple, vous pouvez définir une équipe d'une seule personne pourjouer le monstre face à une équipe de 10 joueurs comme chasseurs.

FlexMatch traite les demandes de mise en relation selon que la partie implique un nombre de joueurs faibleou élevé, comme défini dans l'ensemble de règles. Les parties potentielles allant jusqu'à 40 joueurs sontconsidérées comme étant de petite envergure, tandis que celles qui ont plus de 40 joueurs sont des partiesà grande échelle. Pour déterminer la taille d'une partie potentielle d'un ensemble de règles, ajoutez les maxPlayer paramètres de toutes les équipes définies dans l'ensemble de règles.

• name (obligatoire) – Attribuez un nom unique à chaque équipe. Ce nom sera utilisé dans les règles et lesextensions, et sert de référence dans les données de mise en relation utilisées dans la session de jeu.

• maxPlayers(obligatoire) – Spécifiez le nombre maximal de joueurs qui peuvent être affectés à l'équipe.• minPlayers(obligatoire) – Spécifiez le nombre minimum de joueurs qui doivent être affectés à l'équipe

pour que la mise en relation puisse réussir.• quantity (facultatif) – Si vous voulez que FlexMatch crée plus d'une équipe basée sur cette définition,

spécifiez-en le nombre ici. Lorsque FlexMatch crée une partie, le nom désigné, accompagné d'unnuméro de suivi, est ajouté à ces équipes. Par exemple : « Équipe_Rouge_1 », « Équipe_Rouge_2 »,« Équipe_Rouge_3 », etc.

FlexMatch essaie toujours de remplir entièrement les équipes, mais peut créer des équipes avec moinsde joueurs lorsque la taille minimale le permet. Si vous souhaitez que toutes les équipes de la partiesoient de taille égale, vous pouvez créer une règle à cette fin. Consultez la rubrique Exemples FlexMatchd'ensembles de règles (p. 169) pour obtenir un exemple de règle « EqualTeamSizes ».

Définir des règles pour la mise en relation des joueurs

Créez un ensemble de déclarations de règles qui définissent comment identifier les joueurs pouvantrejoindre une partie. Les règles peuvent définir des exigences qui s'appliquent aux joueurs individuels,à des équipes ou à une partie entière. Lorsque GameLift traite une demande de mise en relation, ilcommence par le joueur qui est dans le pool de joueurs disponibles depuis le plus de temps et crée unepartie en fonction de cette personne.

• name (obligatoire) – Nom significatif qui identifie de manière unique la règle au sein d'un ensemblede règles. Les noms de règle sont également référencés dans les journaux des événements et lesmétriques qui suivent l'activité associée à cette règle.

• description (facultatif) – Utilisez cet élément pour attacher une description au format texte libre. Cesinformations ne sont pas utilisées par le matchmaker.

• type (obligatoire) – L'élément type identifie l'opération à utiliser lors du traitement de la règle. Chaquetype de règle nécessite un ensemble de propriétés supplémentaires. Par exemple, plusieurs typesde règles nécessitent une valeur de référence afin de pouvoir la comparer aux attributs d'un joueur.Pour consulter la liste des types de règles et des propriétés valides, voir Langage FlexMatch desrègles (p. 331).

• Type de propriété de règle (parfois obligatoire) – En fonction du type de règle défini, il se peut quevous deviez définir certaines propriétés de règle. Par exemple, avec les règles de distance et decomparaison, vous devez spécifier l'attribut de joueur à mesurer. Pour en savoir plus sur les propriétés

Version163

Amazon GameLift Manuel du développeurCréer un ensemble de règles

et sur l'utilisation du langage d'expression des propriétés FlexMatch, voir Langage FlexMatch desrègles (p. 331).

Autoriser les exigences à assouplir au fil du temps

Les extensions vous permettent d'assouplir les critères de mise en relation au fil du temps lorsqu'unemise en relation ne peut pas être effectuée. L'objectif de cette fonctionnalité est de trouver la « meilleure »partie possible lorsqu’il n’existe pas de correspondance parfaite. Vous pouvez utiliser une extensionpour assouplir les compétences requises d'un joueur, augmenter les niveaux de latence acceptables oudiminuer le nombre minimum de joueurs requis dans une équipe. En assouplissant les règles avec uneextension, vous pouvez développer progressivement le pool de joueurs qui constituent une rencontreacceptable.

Les extensions sont déclenchées par lorsque l'âge du ticket le plus récent dans la correspondanceincomplète correspond à un temps d'attente d'extension. Lorsqu'un nouveau ticket est ajouté à la miseen relation, l'horloge du temps d'attente d'extension peut être réinitialisée. Vous pouvez personnaliser lafaçon dont les extensions sont déclenchées dans la algorithm section de l'ensemble de règles. Gardezà l'esprit que les temps d'attente des étapes d'extension dans sont absolus. Ils ne sont pas combinés lesuns sur les autres. Par conséquent, si vous avez deux étapes, l'une définie sur 15 et l'autre définie sur 30,la deuxième étape se déclenche 15 secondes après la première étape.

Voici un exemple d'expansion qui augmente progressivement le niveau de compétence minimum requispour la mise en relation. L'ensemble de règles utilise une instruction de règle de distance nommée «SkillDelta » pour exiger que tous les joueurs d'une mise en relation se trouvent dans un rayon de 5niveaux de compétence l'un de l'autre. Si aucune nouvelle correspondance n'est effectuée pendant quinzesecondes, cette extension autorise une différence de niveau de compétence de 10, puis dix secondes plustard autorise une différence de 20.

"expansions": [{ "target": "rules[SkillDelta].maxDistance", "steps": [{ "waitTimeSeconds": 15, "value": 10 }, { "waitTimeSeconds": 25, "value": 20 }] }]

Avec les matchmakers pour lesquels le remplissage automatique est activé, n'assouplissez pas troprapidement vos exigences en matière de nombre de joueurs. Quelques secondes peuvent être nécessairepour que la nouvelle session de jeu démarre et commence le remplissage automatique. Si vous avezdes temps d'attente très courts dans vos étapes d'extension, FlexMatch est susceptible de créerun grand nombre de rencontres partiellement remplies avant que les sessions de jeu nouvellementlancées n'envoient des demandes de remplissage. Une meilleure approche consiste à déclencher votreextension uniquement une fois que le remplissage automatique a tendance à se déclenche pour vosjeux. Cela permet aux joueurs d'accéder à des jeux (nouveaux ou existants) plus rapidement et plusefficacement.FlexMatch Les délais d'extension varient en fonction de la composition de votre équipe. Vousdevez donc effectuer quelques tests pour trouver la meilleure stratégie d'extension pour votre jeu.

Concevoir un ensemble de règles FlexMatch pour une partie à grande échelleSi votre ensemble de règles crée des parties qui autorisent de 41 à 200 joueurs, vous devez apporterquelques modifications à la configuration de votre ensemble de règles. Ces ajustements optimisentl'algorithme de mise en relation afin qu'il puisse créer des parties viables à grande échelle tout enraccourcissant les temps d'attente des joueurs. Par conséquent, les ensembles de règles pour les parties àgrande échelle remplacent les règles personnalisées chronophages par des solutions standard optimiséespour les priorités de mise en relation courantes.

Version164

Amazon GameLift Manuel du développeurCréer un ensemble de règles

Voici comment déterminer si vous devez optimiser votre ensemble de règles pour les parties à grandeéchelle :

1. Pour chaque équipe définie dans votre ensemble de règles, obtenez la valeur de maxPlayer ,2. Ajoutez toutes les maxPlayer valeurs. Si le total dépasse 40, vous disposez d’un ensemble de règles

pour les parties à grande échelle.

Afin d’optimiser votre ensemble de règles pour les parties à grande échelle, effectuez les ajustementsdécrits ci-dessous. Consultez le schéma d’un ensemble de règles pour les parties à grande échelle dansSchéma d’ensemble de règles pour les parties à grande échelle (p. 326) et des exemples d’ensembles derègles dans Exemple 7 : Crée une partie à grande échelle (p. 180) .

Personnalisation de l'algorithme de mise en relation pour les parties à grande échelle

Ajoutez un composant d'algorithme à l'ensemble de règles, s'il n'en existe pas déjà un. Définissez lespropriétés suivantes.

• strategy(obligatoire) – Définissez la strategy propriété sur « balanced ». Ce paramètredéclenche FlexMatch des vérifications post-match supplémentaires pour trouver l'équilibre optimalde l'équipe en fonction d'un attribut de joueur spécifié. Définissez l'attribut de joueur à l'aide de labalancedAttribute propriété . La stratégie équilibrée remplace le besoin de règles personnaliséespour créer des équipes mises en relation uniformément.

• balancedAttribute(obligatoire) – Identifiez un attribut de joueur à utiliser lors de l'équilibrage deséquipes dans une mise en relation. Cet attribut doit avoir un type de données numérique (double ouentier). Par exemple, si vous choisissez d'équilibrer sur la compétence des joueurs, FlexMatch essaied'affecter des joueurs afin que toutes les équipes aient des niveaux de compétence regroupés aussiuniformément que possible. L'attribut d'équilibrage doit être déclaré dans les attributs de joueur del'ensemble de règles.

• batchingPreference(facultatif) – Choisissez l'importance que vous souhaitez accorder à la formationdes rencontres à latence la plus faible possible pour vos joueurs. Ce paramètre affecte la façon dont lestickets de mise en relation sont triés avant de créer des mises en relation. Les options incluent :• La plus grande population. FlexMatch autorise les correspondances à l'aide de tous les tickets

du groupe ayant des valeurs de latence acceptables dans au moins une région en commun. Parconséquent, le groupe de tickets potentiel a tendance à être volumineux, ce qui facilite le remplissagedes parties plus rapidement. Les joueurs peuvent être placés dans des jeux avec une latenceacceptable, mais pas toujours optimale. Si cette propriété n'est pas définie, il s'agit du comportementpar défaut lorsque strategy est défini sur « balanced ».

• La région la plus rapide. FlexMatch pré-trie tous les tickets du groupe en fonction de l'endroit oùils signalent les valeurs de latence les plus faibles. Par conséquent, les rencontres ont tendance àêtre formées avec des joueurs qui signalent une faible latence dans les mêmes régions. Dans lemême temps, le groupe de ticket potentiel pour chaque partie est plus petit, ce qui peut augmenter letemps nécessaire pour remplir une partie. En outre, comme une priorité plus élevée est placée sur lalatence, les joueurs d'une mise en relation peuvent varier plus largement en ce qui concerne l'attributd'équilibrage.

L'exemple suivant configure l'algorithme de correspondance pour qu'il se comporte comme suit : (1) Trierau préalable le groupe de tickets pour regrouper les tickets par région dans laquelle ils ont des valeursde latence acceptables ; (2) Former des lots de tickets triés pour les correspondances ; (3) Créer desrencontres avec des tickets dans un lot et équilibrer les équipes pour équilibrer la compétence moyennedes joueurs.

"algorithm": { "strategy": "balanced", "balancedAttribute": "player_skill", "batchingPreference": "largestPopulation"

Version165

Amazon GameLift Manuel du développeurCréer un ensemble de règles

},

Déclaration des attributs de joueur

Veillez à déclarer l'attribut de joueur qui est utilisé comme attribut d'équilibrage dans l'algorithme del'ensemble de règles. Cet attribut doit être inclus pour chaque joueur dans une demande de mise enrelation. Vous pouvez fournir une valeur par défaut pour l'attribut de joueur, mais l'équilibrage d'attributfonctionne mieux lorsque des valeurs spécifiques au joueur sont fournies.

Définir des équipes

Le processus de définition de la taille et de la structure des équipes est le même que pour les parties depetite envergure, mais la façon dont FlexMatch remplit les équipes est différente. Cela affecte la manièredont les parties sont susceptibles de ressembler lorsqu'elles sont partiellement remplies. En réponse, vouspouvez choisir modifier la taille minimale de vos équipes.

FlexMatch utilise les règles suivantes lors de l'affectation d'un joueur à une équipe. Premièrement, ilrecherche les équipes qui ne comptent pas encore le nombre minimal de joueurs requis. Deuxièmement,parmi ces équipes, il identifie celle qui a le moins de joueurs.

Pour les parties définissant des équipes de taille égale, les joueurs sont ajoutés de manière séquentiellepour chaque équipe jusqu'à ce qu’elles soient pleines. Par conséquent, les équipes d'une mise enrelation ont toujours un nombre presque égal de joueurs, même lorsque la mise en relation n'est paspleine. Actuellement, il n'est pas possible d’imposer des équipes de taille égale dans les partie à grandeéchelle. Pour les parties dont les tailles d’équipes sont asymétriques, le processus est un peu pluscomplexe. Dans ce scénario, les joueurs sont initialement affectés aux équipes les plus grandes qui ontle plus d'emplacements ouverts. Au fur et à mesure que le nombre d'emplacements ouverts devient plusuniformément réparti entre toutes les équipes, les joueurs sont placés dans les équipes plus petites.

Par exemple, supposons que vous disposiez d'un ensemble de règles avec trois équipes. Les équipesrouge et bleue sont toutes les deux définies sur maxPlayers =10, minPlayers =5. L'équipe verte estdéfinie sur maxPlayers =3, minPlayers =2. Voici la séquence de remplissage :

1. Aucune équipe n'a atteint minPlayers . Les équipes rouge et bleue ont 10 emplacements ouverts,tandis que l’équipe verte en compte 3. Les 10 premiers joueurs sont affectés aux équipes rouge etbleue, à hauteur de 5 joeurs par équipe. Les deux équipes ont maintenant atteint minPlayers .

2. L'équipe verte n'a pas encore atteint minPlayers . Les 2 joueurs suivants sont attribués à l'équipeverte. L'équipe verte est maintenant atteinteminPlayers.

3. Avec toutes les équipes désormais dans minPlayers , les joueurs supplémentaires sont désormaisattribués en fonction du nombre d'emplacements ouverts. Les équipes rouge et bleue ont chacune 5emplacements ouverts, tandis que l'équipe verte en compte 1. Les 8 joueurs suivants sont affectésaux équipes rouge et bleue (4 joueurs pour chaque équipe). Toutes les équipes ont désormais 1emplacement ouvert.

4. Les 3 emplacements de joueur restants sont attribués (1 pour chaque équipe) sans ordre particulier.

Définir une règle de latence pour les parties à grande échelle

La mise en relation pour les parties à grande échelle s'appuie principalement sur les optimisations de lastratégie d'équilibrage et du traitement par lots des latences. la plupart des règles personnalisées ne sontpas disponibles. Cependant, vous pouvez créer une règle qui définit une limite stricte pour la latence desjoueurs.

Pour créer cette règle, utilisez le type de latency règle avec la propriété maxLatency . Voici un exemplequi définit une latence maximale de 200 millisecondes pour les joueurs :

"rules": [{ "name": "player-latency",

Version166

Amazon GameLift Manuel du développeurCréer un ensemble de règles

"type": "latency", "maxLatency": 200 }],

Assouplissement des exigences pour les parties à grande échelle

Comme pour les parties de petite envergure, vous pouvez utiliser des extensions pour assouplirprogressivement les exigences de mise en relation lorsqu’aucune partie ne correspond. Avec les partiesà grande échelle, vous avez la possibilité d'assouplir les règles de latence ou le nombre de joueurs del'équipe.

Si vous utilisez le remplissage automatique des parties à grande échelle, patientez un peu avantd'assouplir le nombre de joueurs requis. FlexMatch ne commence à générer les demandes de remplissagequ’après le démarrage d’une session de jeu, ce qui peut ne pas se produire pendant plusieurs secondesaprès la création d’une partie. Parallèlement, FlexMatch permet de créer plusieurs sessions de jeupartiellement remplies, notamment lorsque les règles liées au nombre de joueurs sont abaissées. Dans cecas, vous pouvez vous retrouver avec plus de sessions de jeu que nécessaire et une trop faible répartitiondes joueurs entre eux. Une bonne pratique consiste ici à attribuer à la première étape de l’extension dunombre de joueurs un délai d'attente suffisamment long pour que la session de jeu puisse démarrer. Dansla mesure où les demandes de remplissage sont prioritaires dans les parties à grande échelle, les joueursentrants sont placés dans les jeux existants avant le démarrage de nouveaux jeux. Vous devrez peut-êtreeffectuer plusieurs tests afin de déterminer le temps d'attente idéal pour votre jeu.

Voici un exemple qui réduit progressivement le nombre de joueurs de l'équipe jaune, avec un tempsd'attente initial plus long. Gardez à l'esprit que les délais d'attente des extensions dans les ensembles derègles sont des valeurs absolues, et non composées. Par conséquent, la première extension se produit àcinq secondes, tandis que la seconde extension se produit cinq secondes plus tard, à savoir au bout de dixsecondes.

"expansions": [{ "target": "teams[Yellow].minPlayers", "steps": [{ "waitTimeSeconds": 5, "value": 8 }, { "waitTimeSeconds": 10, "value": 5 }] }]

Créer des ensembles de règles de mise en relationCréez des ensembles de règles de mise en relation pour vos matchmakers FlexMatch. Utilisez laGameLift console Amazon ou l'interface de ligne de commande (CLI) AWS. Pour en savoir plus sur lefonctionnement de la mise en relation FlexMatch, consultez the section called “Fonctionnement d'GameLiftFlexMatch” (p. 15).

Une fois créés, les ensembles de règles de mise en relation ne peuvent pas être modifiés. Par conséquent,nous vous recommandons de vérifier la syntaxe de l'ensemble de règles avant de créer l'ensemble derègles. Dans les deux cas, la console et l'interface de ligne de commande AWS fournissent une optionde validation. Une limite maximale est appliquée au nombre d'ensembles de règles que vous pouvezposséder. Il est donc conseillé de supprimer les ensembles de règles inutilisés.

Voir aussi

• Concevoir un ensemble FlexMatch de règles (p. 158)• Exemples FlexMatch d'ensembles de règles (p. 169)• Langage FlexMatch des règles (p. 331)

Version167

Amazon GameLift Manuel du développeurCréer un ensemble de règles

Console

Pour créer un ensemble de règles :

1. Ouvrez la console Amazon GameLift à l'adresse https://console.aws.amazon.com/gamelift/.2. Basculez vers la région où vous souhaitez placer votre ensemble de règles. Les ensembles de

règles doivent être définis dans la même région que la configuration de mise en relation aveclaquelle ils seront utilisés.

3. Dans le menu principal d'Amazon GameLift, choisissez Créer un nouvel ensemble de règles decorrespondance et complétez les détails de l'ensemble de règles.

• Nom de l'ensemble de règles – Créez un nom pertinent afin de pouvoir l'identifier facilementdans une liste, ainsi que dans les événements et les métriques. Le nom de l'ensemble derègles doit être unique au sein d'une région. Les configurations de mise en relation identifientl'ensemble de règles à utiliser par son nom. Remarque: Ce n'est pas le même que le champ «nom » dans le corps de l'ensemble de règles, qui n'est actuellement pas utilisé.

• Ensemble de règles – Entrez le texte JSON d'un corps d'ensemble de règles. Pour en savoirplus sur la conception d'un ensemble de règles, consultezthe section called “Concevoir unensemble de règles” (p. 158) ou utilisez l'un des exemples d'ensembles de règles dansExemples FlexMatch d'ensembles de règles (p. 169).

4. Étant donné que les ensembles de règles ne peuvent pas être modifiés une fois qu'ils ont étécréés, une bonne idée consiste à valider d'abord votre ensemble de règles. Cliquez sur Validaterule set pour vérifier que la syntaxe du corps de votre ensemble de règles est correcte.

5. Une fois que vous avez fini de configurer un matchmaker, cliquez sur Create rule set. Si lacréation réussit, l'ensemble de règles peut être utilisé par un matchmaker.

Pour supprimer un ensemble de règles :

1. Sur la page de console Ensembles de règles de correspondance, sélectionnez un ensemble derègles et cliquez sur Delete rule set (Supprimer l'ensemble de règles).

2. Si l'ensemble de règles en cours de suppression est actuellement utilisé par une configurationde mise en relation, un message d'erreur s'affiche. Dans ce cas, avant de pouvoir supprimerl'ensemble de règles, vous devez modifier la configuration de mise en relation pour utiliser unautre ensemble de règles. Pour connaître les configurations de mise en relation qui utilisentactuellement un ensemble de règles, cliquez sur le nom de l'ensemble de règles pour afficher sapage de détails.

AWS CLI

Pour créer un ensemble de règles :

• Pour créer un ensemble de règles de mise en relation avec l'AWS CLI, ouvrez une fenêtre deligne de commande et utilisez la commande create-matchmaking-rule-set (Référence descommandes d'AWS CLI). Obtenez et installez l'outil AWS Command Line Interface.

Cet exemple crée un simple ensemble de règles de mise en relation qui configure une seuleéquipe. Veillez à créer l'ensemble de règles dans la même région que la configuration de mise enrelation qui y fera référence.

$ aws gamelift create-matchmaking-rule-set--name "SampleRuleSet123"--rule-set-body '{"name": "aliens_vs_cowboys", "ruleLanguageVersion": "1.0",

Version168

Amazon GameLift Manuel du développeurCréer un ensemble de règles

"teams": [{ "name": "cowboys", "maxPlayers": 8, "minPlayers": 4}]}'

Version 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 demande de création aboutit, Amazon GameLift renvoie un MatchmakingRuleSet objet quiinclut les paramètres que vous avez spécifiés. Le nouvel ensemble de règles peut désormais êtreutilisé par un matchmaker.

Pour supprimer un ensemble de règles :

• Pour supprimer un ensemble de règles de mise en relation avec l'AWS CLI, ouvrez une fenêtre deligne de commande et utilisez la commande delete-matchmaking-rule-set (Référence descommandes d'AWS CLI).

Si l'ensemble de règles en cours de suppression est actuellement utilisé par une configurationde mise en relation, un message d'erreur s'affiche. Dans ce cas, avant de pouvoir supprimerl'ensemble de règles, vous devez modifier la configuration de mise en relation pour utiliserun autre ensemble de règles. Pour obtenir la liste des configurations de mise en relation quiutilisent actuellement un ensemble de règles, utilisez la commande describe-matchmaking-configurations (Référence des commandes d'AWS CLI) et spécifiez le nom de l'ensemble derègles.

Cet exemple vérifie d'abord l'utilisation de l'ensemble de règles de mise en relation, puis supprimel'ensemble de règles.

$ aws gamelift describe-matchmaking-configurations--rule-set-name "SampleRuleSet123"--limit 10

$ aws gamelift delete-matchmaking-rule-set--name "SampleRuleSet123"

Versions copiables :

aws gamelift describe-matchmaking-configurations --rule-set-name "SampleRuleSet123" --limit 10

aws gamelift delete-matchmaking-rule-set --name "SampleRuleSet123"

Si la demande de suppression aboutit, Amazon GameLift indique que l'opération a réussi.

Exemples FlexMatch d'ensembles de règlesLes ensembles de règles FlexMatch peuvent couvrir différents scénarios de mise en relation. Les exemplessuivants sont conformes à la structure de la configuration et du langage d'expression de propriété

Version169

Amazon GameLift Manuel du développeurCréer un ensemble de règles

FlexMatch. Copiez entièrement ces ensembles de règles ou choisissez des éléments en fonction de vosbesoins.

Pour plus d'informations sur l'utilisation de règles et d'ensembles de règles FlexMatch, consultez lesrubriques suivantes :

• Créer un ensemble FlexMatch de règles (p. 158)• Concevoir un ensemble FlexMatch de règles (p. 158)• ensemble FlexMatch de règles schéma (p. 324)• Langage FlexMatch des règles (p. 331)

Note

Lorsque vous évaluez une demande de mise en relation incluant plusieurs joueurs, tous lesjoueurs de la demande doivent satisfaire aux exigences de mise en relation.

Exemple 1 : Créer deux équipes avec des joueurs mis en relation de manièreuniforme

Cet exemple illustre la configuration de deux équipes ayant un nombre identique de joueurs mis en relationavec les instructions suivantes.

• Créez deux équipes de joueurs.• Inclure entre quatre et huit joueurs dans chaque équipe.• Au final, les équipes doivent avoir le même nombre de joueurs.

• Inclure un niveau de compétence pour les joueurs (si aucune valeur n'est fournie, la valeur par défaut est10).

• Choisissez les joueurs en fonction de leur niveau de compétences, qui doit être similaire à celui d'autresjoueurs. Assurez-vous que le niveau moyen de compétence des deux équipes diffère de 10 pointsmaximum.

• Si la mise en relation n'est pas effectuée rapidement, assouplissez les exigences du niveau decompétences pour que la mise en relation soit réalisée dans un délai raisonnable.• Après 5 secondes, étendez la recherche pour autoriser un écart moyen de compétences des joueurs

de 50 points maximum.• Après 15 secondes, étendez la recherche pour autoriser un écart moyen de compétences des joueurs

de 100 points maximum.

Remarques sur l'utilisation de cet ensemble de règles :

• Cet exemple permet de disposer d'équipes composées de 4 à 8 joueurs (même si elles doivent être demême taille). Pour les équipes offrant plusieurs tailles valides, le matchmaker fait de son mieux pourmettre en relation le nombre maximal de joueurs autorisés.

• La règle FairTeamSkill garantit que les équipes sont mises en relation de façon uniforme enfonction de la compétence des joueurs. Pour évaluer cette règle pour chaque nouveau joueur potentiel,FlexMatch ajoute provisoirement le joueur à une équipe et calcule les moyennes. Si la règle échoue, lejoueur potentiel n'est pas ajouté à la mise en relation.

• Étant donné que les deux équipes ont des structures identiques, vous pouvez choisir de créer uneseule définition d'équipe et de définir la quantité de l'équipe sur « 2 ». Dans ce scénario, si vous aveznommé l'équipe « extra-terrestres », vos équipes recevront les noms « extra-terrestres_1" et « extra-terrestres_2".

{

Version170

Amazon GameLift Manuel du développeurCréer un ensemble de règles

"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 "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 }] }]}

Exemple 2 : Créer des équipes de nombre inégal (Chasseurs/Monstre)

Cet exemple décrit un mode de jeu dans lequel un groupe de joueurs chasse un seul monstre. Les joueurschoisissent un rôle de chasseur ou un rôle de monstre. Les chasseurs spécifient le niveau minimal decompétence du monstre qu'ils souhaitent affronter. La taille minimale de l'équipe de chasseurs peut êtreassouplie au fil du temps pour réaliser la mise en relation. Ce scénario établit les instructions suivantes :

• Créez une équipe comportant exactement cinq chasseurs.• Créez une équipe distincte comportant un seul monstre.• Définissez les attributs suivants pour les joueurs :

• Un niveau de compétence pour les joueurs (si aucune valeur n'est fournie, la valeur par défaut est 10).• Un niveau de compétence souhaité pour le monstre (si aucune valeur n'est fournie, la valeur par défaut

est 10).

Version171

Amazon GameLift Manuel du développeurCréer un ensemble de règles

• Si le joueur souhaite être le monstre (si cette valeur n'est pas renseignée, la valeur par défaut est 0 oufalse).

• Choisissez le joueur qui sera le monstre en fonction des critères suivants :• Le joueur doit demander le rôle de monstre.• Le niveau de compétence du joueur doit correspondre ou être supérieur au niveau de compétence le

plus élevé souhaité par les joueurs qui ont déjà intégré l'équipe de chasseurs.• Choisissez les joueurs de l'équipe de chasseurs en fonction des critères suivants :

• Les joueurs qui demandent le rôle de monstre ne peuvent pas être intégrés à l'équipe de chasseurs.• Si le rôle de monstre est déjà attribué, le joueur doit vouloir un niveau de compétence pour le monstre

qui soit inférieur à la compétence du monstre proposé.• Si la mise en relation n'est pas effectuée rapidement, assouplissez les critères de taille minimale de

l'équipe des chasseurs de la manière suivante :• Après 30 secondes, autorisez le démarrage du jeu avec seulement quatre joueurs dans l'équipe des

chasseurs.• Après 60 secondes, autorisez le démarrage du jeu avec seulement trois joueurs dans l'équipe des

chasseurs.

Remarques sur l'utilisation de cet ensemble de règles :

• En utilisant deux équipes distinctes pour les chasseurs et le monstre, vous pouvez évaluer les membresen fonction de différents ensembles de critères.

{ "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",

Version172

Amazon GameLift Manuel du développeurCréer un ensemble de règles

"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 }] }]}

Exemple 3 : Définir les exigences au niveau de l'équipe et les limites de latence

Cet exemple illustre la configuration d’équipes de joueurs et l'application d'un ensemble de règles àchacune d’elles plutôt qu'à chaque joueur. Il utilise une seule définition pour créer trois équipes de tailleégale. Il établit également une latence maximale pour tous les joueurs. Les valeurs maximales de latencepeuvent être assouplies au fil du temps pour réaliser la mise en relation. Ce scénario établit les instructionssuivantes :

• Créez trois équipes de joueurs.• Inclure entre trois et cinq joueurs dans chaque équipe.• Au final, les équipes doivent avoir le même nombre de joueurs ou un joueur d'écart.

• Définissez les attributs suivants pour les joueurs :• Un niveau de compétence pour les joueurs (si aucune valeur n'est fournie, la valeur par défaut est 10).• Un rôle pour chaque joueur (si aucune valeur n'est fournie, la valeur par défaut est « paysan »).

• Choisissez les joueurs en fonction de leur niveau de compétences, qui doit être similaire à celui d'autresjoueurs de la relation.• Assurez-vous que le niveau moyen de compétence de chaque équipe diffère de 10 points maximum.

• Limitez le nombre de personnages « médecin » dans chaque équipe :• Le nombre maximum de médecins d'une relation complète est 5.

• Seuls les joueurs dont la latence est de 50 millisecondes ou moins doivent être pris en compte.• Si la mise en relation n'est pas effectuée rapidement, assouplissez le critère de latence pour les joueurs

de la manière suivante :• Après 10 secondes, autoriser les valeurs de latence pour les joueurs jusqu'à 100 ms.• Après 20 secondes, autoriser les valeurs de latence pour les joueurs jusqu'à 150 ms.

Remarques sur l'utilisation de cet ensemble de règles :

• L'ensemble de règles garantit que les équipes sont mises en relation de façon uniforme en fonction dela compétence des joueurs. Pour évaluer la règle FairTeamSkill, FlexMatch ajoute provisoirementle joueur potentiel à une équipe et calcule le niveau de compétence moyen des joueurs de l'équipe.

Version173

Amazon GameLift Manuel du développeurCréer un ensemble de règles

Ensuite, il le compare au niveau de compétence moyen des joueurs dans les deux équipes. Si la règleéchoue, le joueur potentiel n'est pas ajouté à la mise en relation.

• Pour respecter les exigences au niveau de l'équipe et de la mise en relation (nombre total de médecins)un ensemble de règles est utilisé. Ce type de règle vérifie la liste des attributs de personnages pour tousles joueurs par rapport au nombre maximum. Utilisez flatten pour créer une liste pour tous les joueursdans toutes les équipes.

• Lors de l'évaluation basée sur la latence, notez les éléments suivants :• Les données de latence sont fournies dans la demande de mise en relation dans le carte de l'objet

Player (joueur). Il ne s'agit pas d'un attribut de joueur, il n'a donc pas besoin d'être répertorié en tantque tel.

• Le matchmaker évalue la latence par région. Toute région dont la latence est plus élevée que lalatence maximale est ignorée. Pour être accepté pour une mise en relation, un joueur doit avoir aumoins une région avec une latence inférieure au maximum.

• Si une demande de mise en relation omet les données de latence pour un ou plusieurs joueurs, lademande est rejetée pour toutes les relations.

{ "name": "three_team_game", "ruleLanguageVersion": "1.0", "playerAttributes": [{ "name": "skill", "type": "number", "default": 10 },{ "name": "character", "type": "string_list", "default": [ "peasant" ] }], "teams": [{ "name": "trio", "minPlayers": 3, "maxPlayers": 5, "quantity": 3 }], "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])"],

Version174

Amazon GameLift Manuel du développeurCréer un ensemble de règles

"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 }] }]}

Exemple 4 : Utiliser le tri explicite pour trouver les meilleures correspondances

Cet exemple montre la configuration d'une mise en relation simple avec deux équipes de trois joueurs.Il montre comment utiliser les règles de tri explicite pour aider à trouver les meilleures mises en relationpossibles aussi rapidement que possible. Ces règles trient tous les tickets de mise en relation actifs pourcréer les meilleures mises en relation en fonction de certaines exigences clés. Ce scénario est implémentéavec les instructions suivantes :

• Créez deux équipes de joueurs.• Inclure exactement trois joueurs dans chaque équipe.• Définissez les attributs suivants pour les joueurs :

• Niveau d'expérience (si aucune valeur n'est fournie, la valeur par défaut est 50).• Modes de jeu préférés (peut contenir plusieurs valeurs) (si aucune valeur n'est fournie, les valeurs par

défaut sont « coop » et « deathmatch »).• Relations de jeu préférées, indiquant le nom de la mise en relation et la pondération des préférences

(si aucune valeur n'est fournie, la valeur par défaut est "defaultMap" avec une pondération de 100).• Configurez le tri préalable :

• Triez les joueurs en fonction de leurs préférences pour la même relation de jeu en tant que joueurd'ancrage. Les joueurs peuvent avoir plusieurs relations de jeu préférées, c'est pourquoi cet exempleutilise une valeur de préférence.

• Triez les joueurs en fonction du degré de correspondance de leur niveau d'expérience avec celui dujoueur d'ancrage. Ce tri permet de rapprocher le mieux possible les niveaux d'expérience de tous lesjoueurs de toutes les équipes.

• Tous les joueurs dans toutes les équipes doivent avoir sélectionné au moins un mode de jeu encommun.

• Tous les joueurs dans toutes les équipes doivent avoir sélectionné au moins une relation de jeu encommun.

Remarques sur l'utilisation de cet ensemble de règles :

• Le tri de la relation de jeu utilise un tri absolu qui compare la valeur mapPreference de l'attribut. Commeil s’agit de la première valeur dans l'ensemble de règles, ce tri est effectuée en premier.

• Le tri utilise un paramètre de distance pour comparer le niveau de compétence d'un joueur potentiel parrapport à celui du joueur d'ancrage.

Version175

Amazon GameLift Manuel du développeurCréer un ensemble de règles

• Les tris sont exécutés dans l'ordre dans lequel ils sont répertoriés dans un ensemble de règles. Dans cescénario, les joueurs sont triés par préférence de relation de jeu, puis par niveau d'expérience.

{ "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", "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",

Version176

Amazon GameLift Manuel du développeurCréer un ensemble de règles

"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 }]}

Exemple 5 : Recherche d'intersections sur plusieurs attributs de joueurCet exemple illustre comment utiliser une règle de collection pour rechercher des intersections dansdeux attributs de joueur ou plus. Lorsque vous utilisez des collections, vous pouvez utiliser l'opérationintersection pour un attribut unique, et l'opération reference_intersection_count pour plusieursattributs.

Pour illustrer cette approche, cet exemple évalue les joueurs d'une mise en relation en fonction de leurspréférences de personnages. L'exemple de jeu est un style « empoigne » dans laquelle tous les joueursd'une mise en relation sont adversaires. Chaque joueur est invité à (1) choisir un personnage pour lui-même, et (2) à choisir les personnages contre lesquels il veut jouer. Nous avons besoin d'une règle quigarantit que chaque joueur d'une mise en relation utilise un personnage figurant sur la liste des adversairespréférés de tous les autres joueurs.

L'exemple d'ensemble de règles décrit une mise en relation avec les caractéristiques suivantes :

• Structure de l'équipe : Une équipe de cinq joueurs• Attributs du joueur :

• myCharacter: Personnage choisi par le joueur.• preferredOpponents: Liste des personnages contre lesquels le joueur souhaite jouer.

• Règles de correspondance : Une mise en relation potentielle est acceptable si chaque personnage encours d'utilisation figure sur la liste des adversaires préférés de chaque joueur.

Pour implémenter la règle de mise en relation, cet exemple utilise une règle de collection avec les valeursde propriété suivantes :

• Opération – Utilise l'opération reference_intersection_count pour évaluer la façon dont chaqueliste de chaînes de la valeur de mesure interagit avec la liste de chaînes de la valeur de référence.

• Les mesures – : utilise l'expression de flatten propriété pour créer une liste de listes de chaînes, avecchaque liste de chaînes contenant la valeur d'myCharacterattribut d'un joueur.

• Valeur de référence – : utilise l'expression de set_intersection propriété pour créer une liste dechaînes de toutes les valeurs dpreferredOpponents'attribut communes à chaque joueur de la mise enrelation.

• Restrictions – minCount est défini sur 1 afin de s'assurer que le personnage choisi par chaque joueur(une liste de chaînes de la mesure) correspond à au moins un des adversaires préférés communs à tousles joueurs (une chaîne dans la valeur de référence).

• Extension : si la mise en relation n'est pas remplie dans un délai de 15 secondes, assouplissezl'exigence d'intersection minimale.

Le processus pour cette règle se présente comme suit :

1. Un joueur est ajouté à la mise en relation potentielle. La valeur de référence (une liste de chaînes) estrecalculée afin d'inclure les intersections avec la liste des adversaires préférés du nouveau joueur. La

Version177

Amazon GameLift Manuel du développeurCréer un ensemble de règles

valeur de mesure (une liste de listes de chaînes) est recalculée pour ajouter le caractère choisi par lenouveau joueur en tant que nouvelle liste de chaînes.

2. Amazon GameLift vérifie que chaque liste de chaînes de la valeur de mesure (les personnages choisispar le joueur) interagisse avec au moins une chaîne de la valeur de référence (les adversaires préférésdu joueur). Comme dans cet exemple, chaque liste de chaînes de la mesure ne contient qu'une seulevaleur, l'intersection est 0 ou 1.

3. Si aucune liste de chaînes de la mesure n'interagit avec la liste de chaînes de la valeur de référence, larègle échoue et le nouveau joueur est supprimé de la mise en relation potentielle.

4. Si une mise en relation n'est pas remplie dans un délai de 15 secondes, abandonnez l'exigence de miseen relation de l'adversaire afin de remplir les emplacements restants du joueur dans la mise en relation.

{ "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 }] }]}

Exemple 6 : Comparer les attributs de tous les joueurs

Cet exemple illustre la façon de comparer les attributs d'un joueur à un groupe de joueurs.

L'exemple d'ensemble de règles décrit une mise en relation avec les caractéristiques suivantes :

• Structure de l'équipe : Deux équipes monojoueur• Attributs du joueur :

• gameMode: Type de jeu choisi par le joueur (si aucune valeur n'est fournie, la valeur par défaut est «turn-based »).

Version178

Amazon GameLift Manuel du développeurCréer un ensemble de règles

• gameMap: World jeu choisi par le joueur (si aucune valeur n'est fournie, la valeur par défaut est 1).• caractère : Personnage choisi par le joueur (l'absence de valeur par défaut signifie que les joueurs

doivent spécifier un personnage).• Règles de correspondance : Les joueurs mis en relation doivent répondre aux critères suivants :

• Les joueurs doivent choisir le même mode de jeu.• Les joueurs doivent choisir la même relation de jeu.• Les joueurs doivent choisir des personnages différents.

Remarques sur l'utilisation de cet ensemble de règles :

• Pour implémenter la règle de mise en relation, cet exemple utilise des règles de comparaison permettantde vérifier les valeurs d'attribut de tous les joueurs. Pour le mode et la relation de jeu, la règle vérifie queles valeurs sont identiques. Pour le personnage, la règle vérifie que les valeurs sont différentes.

• Cet exemple utilise une seule définition de joueur avec une propriété de quantité pour créer les deuxéquipes de joueurs. Les équipes se voient attribuer les noms suivants : « joueur_1 » et « joueur_2 ».

{ "name": "", "ruleLanguageVersion": "1.0",

"playerAttributes": [{ "name": "gameMode", "type": "string", "default": "turn-based" }, { "name": "gameMap", "type": "number", "default": 1 }, { "name": "character", "type": "number" }],

"teams": [{ "name": "player", "minPlayers": 1, "maxPlayers": 1, "quantity": 2 }],

"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])"] }]

Version179

Amazon GameLift Manuel du développeurCréer un ensemble de règles

}

Exemple 7 : Crée une partie à grande échelleCet exemple illustre comment configurer un ensemble de règles pour une partie pouvant impliquer plus de40 joueurs. Lorsqu'un ensemble de règles décrit des équipes dont le maxPlayer nombre total est supérieurà 40, il est traité comme une partie à grande échelle. Pour en savoir plus, voir

Si votre ensemble de règles crée des parties qui autorisent de 41 à 200 joueurs, vousdevez apporter quelques modifications à la configuration de votre ensemble de règles.Ces ajustements optimisent l'algorithme de mise en relation afin qu'il puisse créer desparties viables à grande échelle tout en raccourcissant les temps d'attente des joueurs. Parconséquent, les ensembles de règles pour les parties à grande échelle remplacent les règlespersonnalisées chronophages par des solutions standard optimisées pour les priorités de miseen relation courantes.

Voici comment déterminer si vous devez optimiser votre ensemble de règles pour les parties àgrande échelle :

1. Pour chaque équipe définie dans votre ensemble de règles, obtenez la valeur de maxPlayer,

2. Ajoutez toutes les maxPlayer valeurs. Si le total dépasse 40, vous disposez d’un ensemblede règles pour les parties à grande échelle.

Afin d’optimiser votre ensemble de règles pour les parties à grande échelle, effectuez lesajustements décrits ci-dessous. Consultez le schéma d’un ensemble de règles pour lesparties à grande échelle dans Schéma d’ensemble de règles pour les parties à grandeéchelle (p. 326) et des exemples d’ensembles de règles dans Exemple 7 : Crée une partie àgrande échelle (p. 180) .

Personnalisation de l'algorithme de mise en relation pour les parties à grande échelle

Ajoutez un composant d'algorithme à l'ensemble de règles, s'il n'en existe pas déjà un.Définissez les propriétés suivantes.

• strategy(obligatoire) – Définissez la strategy propriété sur « balanced ». Ce paramètredéclenche FlexMatch des vérifications post-match supplémentaires pour trouver l'équilibreoptimal de l'équipe en fonction d'un attribut de joueur spécifié. Définissez l'attribut de joueurà l'aide de la balancedAttribute propriété . La stratégie équilibrée remplace le besoin derègles personnalisées pour créer des équipes mises en relation uniformément.

• balancedAttribute(obligatoire) – Identifiez un attribut de joueur à utiliser lors del'équilibrage des équipes dans une mise en relation. Cet attribut doit avoir un type dedonnées numérique (double ou entier). Par exemple, si vous choisissez d'équilibrer sur lacompétence des joueurs, FlexMatch essaie d'affecter des joueurs afin que toutes les équipesaient des niveaux de compétence regroupés aussi uniformément que possible. L'attributd'équilibrage doit être déclaré dans les attributs de joueur de l'ensemble de règles.

• batchingPreference(facultatif) – Choisissez l'importance que vous souhaitez accorder àla formation des rencontres à latence la plus faible possible pour vos joueurs. Ce paramètreaffecte la façon dont les tickets de mise en relation sont triés avant de créer des mises enrelation. Les options incluent :• La plus grande population. FlexMatch autorise les correspondances à l'aide de tous les

tickets du groupe ayant des valeurs de latence acceptables dans au moins une région encommun. Par conséquent, le groupe de tickets potentiel a tendance à être volumineux, cequi facilite le remplissage des parties plus rapidement. Les joueurs peuvent être placésdans des jeux avec une latence acceptable, mais pas toujours optimale. Si cette propriétén'est pas définie, il s'agit du comportement par défaut lorsque strategy est défini sur «balanced ».

Version180

Amazon GameLift Manuel du développeurCréer un ensemble de règles

• La région la plus rapide. FlexMatch pré-trie tous les tickets du groupe en fonction del'endroit où ils signalent les valeurs de latence les plus faibles. Par conséquent, les

rencontres ont tendance à être formées avec des joueurs qui signalent une faible latencedans les mêmes régions. Dans le même temps, le groupe de ticket potentiel pour chaquepartie est plus petit, ce qui peut augmenter le temps nécessaire pour remplir une partie. Enoutre, comme une priorité plus élevée est placée sur la latence, les joueurs d'une mise enrelation peuvent varier plus largement en ce qui concerne l'attribut d'équilibrage.

L'exemple suivant configure l'algorithme de correspondance pour qu'il se comporte commesuit : (1) Trier au préalable le groupe de tickets pour regrouper les tickets par région danslaquelle ils ont des valeurs de latence acceptables ; (2) Former des lots de tickets triés pourles correspondances ; (3) Créer des rencontres avec des tickets dans un lot et équilibrer leséquipes pour équilibrer la compétence moyenne des joueurs.

"algorithm": {

"strategy": "balanced",

"balancedAttribute": "player_skill",

"batchingPreference": "largestPopulation"

},

Déclaration des attributs de joueur

Veillez à déclarer l'attribut de joueur qui est utilisé comme attribut d'équilibrage dansl'algorithme de l'ensemble de règles. Cet attribut doit être inclus pour chaque joueur dans unedemande de mise en relation. Vous pouvez fournir une valeur par défaut pour l'attribut dejoueur, mais l'équilibrage d'attribut fonctionne mieux lorsque des valeurs spécifiques au joueursont fournies.

Définir des équipes

Le processus de définition de la taille et de la structure des équipes est le même que pour lesparties de petite envergure, mais la façon dont FlexMatch remplit les équipes est différente.Cela affecte la manière dont les parties sont susceptibles de ressembler lorsqu'elles sontpartiellement remplies. En réponse, vous pouvez choisir modifier la taille minimale de voséquipes.

FlexMatch utilise les règles suivantes lors de l'affectation d'un joueur à une équipe.Premièrement, il recherche les équipes qui ne comptent pas encore le nombre minimal dejoueurs requis. Deuxièmement, parmi ces équipes, il identifie celle qui a le moins de joueurs.

Pour les parties définissant des équipes de taille égale, les joueurs sont ajoutés de manièreséquentielle pour chaque équipe jusqu'à ce qu’elles soient pleines. Par conséquent, leséquipes d'une mise en relation ont toujours un nombre presque égal de joueurs, même lorsquela mise en relation n'est pas pleine. Actuellement, il n'est pas possible d’imposer des équipesde taille égale dans les partie à grande échelle. Pour les parties dont les tailles d’équipes sontasymétriques, le processus est un peu plus complexe. Dans ce scénario, les joueurs sontinitialement affectés aux équipes les plus grandes qui ont le plus d'emplacements ouverts. Aufur et à mesure que le nombre d'emplacements ouverts devient plus uniformément réparti entretoutes les équipes, les joueurs sont placés dans les équipes plus petites.

Par exemple, supposons que vous disposiez d'un ensemble de règles avec trois équipes.Les équipes rouge et bleue sont toutes les deux définies sur maxPlayers =10, minPlayers=5. L'équipe verte est définie sur maxPlayers =3, minPlayers =2. Voici la séquence deremplissage :

1. Aucune équipe n'a atteint minPlayers . Les équipes rouge et bleue ont 10 emplacementsouverts, tandis que l’équipe verte en compte 3. Les 10 premiers joueurs sont affectés aux

Version181

Amazon GameLift Manuel du développeurCréer un ensemble de règles

équipes rouge et bleue, à hauteur de 5 joeurs par équipe. Les deux équipes ont maintenantatteint minPlayers .

2. L'équipe verte n'a pas encore atteint minPlayers . Les 2 joueurs suivants sont attribués àl'équipe verte. L'équipe verte est maintenant atteinteminPlayers.

3. Avec toutes les équipes désormais dans minPlayers , les joueurs supplémentaires sontdésormais attribués en fonction du nombre d'emplacements ouverts. Les équipes rouge etbleue ont chacune 5 emplacements ouverts, tandis que l'équipe verte en compte 1. Les 8joueurs suivants sont affectés aux équipes rouge et bleue (4 joueurs pour chaque équipe).Toutes les équipes ont désormais 1 emplacement ouvert.

4. Les 3 emplacements de joueur restants sont attribués (1 pour chaque équipe) sans ordreparticulier.

Définir une règle de latence pour les parties à grande échelle

La mise en relation pour les parties à grande échelle s'appuie principalement sur lesoptimisations de la stratégie d'équilibrage et du traitement par lots des latences. la plupart desrègles personnalisées ne sont pas disponibles. Cependant, vous pouvez créer une règle quidéfinit une limite stricte pour la latence des joueurs.

Pour créer cette règle, utilisez le type de latency règle avec la propriété maxLatency . Voiciun exemple qui définit une latence maximale de 200 millisecondes pour les joueurs :

"rules": [{

"name": "player-latency",

"type": "latency",

"maxLatency": 200

}],

Assouplissement des exigences pour les parties à grande échelle

Comme pour les parties de petite envergure, vous pouvez utiliser des extensions pour assouplirprogressivement les exigences de mise en relation lorsqu’aucune partie ne correspond. Avecles parties à grande échelle, vous avez la possibilité d'assouplir les règles de latence ou lenombre de joueurs de l'équipe.

Si vous utilisez le remplissage automatique des parties à grande échelle, patientez un peuavant d'assouplir le nombre de joueurs requis. FlexMatch ne commence à générer lesdemandes de remplissage qu’après le démarrage d’une session de jeu, ce qui peut ne pas seproduire pendant plusieurs secondes après la création d’une partie. Parallèlement, FlexMatchpermet de créer plusieurs sessions de jeu partiellement remplies, notamment lorsque les règlesliées au nombre de joueurs sont abaissées. Dans ce cas, vous pouvez vous retrouver avecplus de sessions de jeu que nécessaire et une trop faible répartition des joueurs entre eux.Une bonne pratique consiste ici à attribuer à la première étape de l’extension du nombre dejoueurs un délai d'attente suffisamment long pour que la session de jeu puisse démarrer. Dansla mesure où les demandes de remplissage sont prioritaires dans les parties à grande échelle,les joueurs entrants sont placés dans les jeux existants avant le démarrage de nouveaux jeux.Vous devrez peut-être effectuer plusieurs tests afin de déterminer le temps d'attente idéal pourvotre jeu.

Voici un exemple qui réduit progressivement le nombre de joueurs de l'équipe jaune, avec untemps d'attente initial plus long. Gardez à l'esprit que les délais d'attente des extensions dansles ensembles de règles sont des valeurs absolues, et non composées. Par conséquent, lapremière extension se produit à cinq secondes, tandis que la seconde extension se produit cinqsecondes plus tard, à savoir au bout de dix secondes.

"expansions": [{

Version182

Amazon GameLift Manuel du développeurCréer un ensemble de règles

"target": "teams[Yellow].minPlayers",

"steps": [{

"waitTimeSeconds": 5,

"value": 8

}, {

"waitTimeSeconds": 10,

"value": 5

}]

}]

(p. 164).

Cet exemple d’ensemble de règles crée une partie avec les instructions suivantes :

• Créer une équipe pouvant compter jusqu'à 200 joueurs, avec un minimum de 175 joueurs.• Critères d'équilibrage : Sélectionnez les joueurs en fonction d'un niveau de compétence similaire. Tous

les joueurs doivent indiquer leur niveau de compétence pour pouvoir être mis en relation.• Préférence de traitement par lots : Regrouper les joueurs selon des critères d'équilibrage similaires lors

de la création de rencontres.• Règles de latence : Définissez une latence maximum acceptable de 150 millisecondes pour les joueurs.• Si la mise en relation n'est pas effectuée rapidement, assouplissez les exigences pour que la partie

puisse se remplir dans un délai raisonnable.• Après 10 secondes, accepter une équipe avec 150 joueurs.• Après 12 secondes, augmenter la latence maximum acceptable en la faisant passer à

200 millisecondes.• Après 15 secondes, accepter une équipe avec 100 joueurs.

Remarques sur l'utilisation de cet ensemble de règles :

• Étant donné que l'algorithme utilise la préférence de traitement par lots largestPopulation, les joueurssont d'abord triés en fonction des critères d’équilibrage. Par conséquent, les parties ont tendance àaccueillir plus de joueurs aux compétences similaires. Tous les joueurs répondent aux exigences delatence acceptables, mais n’ont pas forcément la meilleure latence possible pour leur emplacement.

• La stratégie d'algorithme utilisée dans cet ensemble de règles, « largest population », est le paramètrepar défaut. Pour utiliser la valeur par défaut, vous pouvez choisir d'omettre le paramètre.

• Si vous avez activé le remplissage des parties, patientez un peu avant d’assouplir les exigences relativesau nombre de joueurs. Dans le cas contraire, vous risquez de vous retrouver avec un trop grand nombrede sessions de jeu partiellement remplies. Pour en savoir plus, voir Assouplissement des exigences pourles parties à grande échelle (p. 167).

{ "name": "free-for-all", "ruleLanguageVersion": "1.0", "playerAttributes": [{ "name": "skill", "type": "number" }], "algorithm": { "balancedAttribute": "skill", "strategy": "balanced", "batchingPreference": "largestPopulation" }, "teams": [{ "name": "Marauders", "maxPlayers": 200, "minPlayers": 175

Version183

Amazon GameLift Manuel du développeurCréer un ensemble de règles

}], "rules": [{ "name": "low-latency", "description": "Sets maximum acceptable latency", "type": "latency", "maxLatency": 150 }], "expansions": [{ "target": "rules[low-latency].maxLatency", "steps": [{ "waitTimeSeconds": 12, "value": 200 }], "target": "teams[Marauders].minPlayers", "steps": [{ "waitTimeSeconds": 10, "value": 150 }, { "waitTimeSeconds": 15, "value": 100 }] }]}

Exemple 8 : Crée une partie à grande échelle avec plusieurs équipes

Cet exemple illustre comment configurer un ensemble de règles pour une partie entre plusieurs équipespouvant impliquer plus de 40 joueurs. Il indique comment créer plusieurs équipes identiques avec uneseule définition et présente comment les équipes de taille asymétrique sont remplies au cours de lacréation d’une partie.

Cet exemple d’ensemble de règles crée une partie avec les instructions suivantes :

• Créer dix équipes « chasseur » identiques avec jusqu'à 15ˆjoueurs, et une équipe « monstre » avecexactement 5 joueurs.

• Critères d'équilibrage : Sélectionnez les joueurs en fonction du nombre de monstres tués. Si les joueursne rapportent pas leur nombre de monstres tués, utiliser la valeur par défaut 5.

• Préférence de traitement par lots : Regrouper les joueurs en fonction des régions où ils signalent lalatence la plus rapide pour les joueurs.

• Règle de latence : Définit une latence maximum acceptable de 200 millisecondes pour les joueurs.• Si la mise en relation n'est pas effectuée rapidement, assouplissez les exigences pour que la partie

puisse se remplir dans un délai raisonnable.• Après 15 secondes, accepter les équipes avec 10 joueurs.• Après 20 secondes, accepter les équipes avec 8 joueurs.

Remarques sur l'utilisation de cet ensemble de règles :

• Cet ensemble de règles définit les équipes qui peuvent contenir jusqu'à 155 joueurs, ce qui fait une partieà grande échelle. (10 x 15 chasseurs + 5 monstres = 155)

• Étant donné que l'algorithme utilise la préférence de traitement par lots fastestRegion, les joueurs onttendance à être placés dans les régions où ils signalent une latence plus rapide et non dans celles oùils signalent une latence élevée (mais acceptable). Parallèlement, les parties sont susceptibles d'avoirmoins de joueurs, et les critères d'équilibrage (nombre de monstres tués) peuvent varier plus largement.

• Lorsqu'une extension est spécifiée pour une définition d'équipe (quantité > 1), elle s'applique à toutesles équipes créées avec cette définition. Par conséquent, en assouplissant le paramètre lié au nombreminimum de joueurs d’une équipe de chasseurs, les dix équipes de chasseurs sont affectées de manièreégale.

Version184

Amazon GameLift Manuel du développeurCréer un ensemble de règles

• Étant donné que cet ensemble de règles est optimisé pour réduire la latence des joueurs, la règle delatence exclut tous les joueurs qui n'ont pas d'options de connexion acceptables. Il n'est pas nécessaired'assouplir cette exigence.

• Voici comment FlexMatch remplit les parties pour cet ensemble de règles avant l'entrée en vigueur desextensions :• Aucune équipe n'a encore atteint minPlayers son nombre. Les équipes de chasseurs ont 15

emplacements ouverts, tandis que l'équipe Monstre compte 5 emplacements ouverts.• Les 100 premiers joueurs sont affectés aux dix équipes de chasseurs (10 joueurs pour chaque

équipe).• Les 22 joueurs suivants seront affectés de manière séquentielle (2 joueurs pour chaque équipe) aux

équipes de chasseurs et à l’équipe Monstre.• Les équipes de chasseurs ont chacune atteint le minPlayers nombre de 12 joueurs. L'équipe Monstre

a 2 joueurs et n'a pas atteint minPlayers son nombre.• Les trois joueurs suivants sont donc attribués cette équipe.

• Toutes les équipes ont atteint le minPlayers nombre requis. Les équipes de chasseurs ont chacunetrois emplacements ouverts. L’équipe Monstre est au complet.• Les 30 derniers joueurs sont affectés de manière séquentielle aux équipes de chasseurs, en

s'assurant qu’elles ont toutes presque la même taille (à un joueur près).• Si vous avez activé le remplissage des parties créées avec cet ensemble de règles, patientez un peu

avant d’assouplir les exigences relatives au nombre de joueurs. Dans le cas contraire, vous risquez devous retrouver avec un trop grand nombre de sessions de jeu partiellement remplies. Pour en savoirplus, voir Assouplissement des exigences pour les parties à grande échelle (p. 167).

{ "name": "monster-hunters", "ruleLanguageVersion": "1.0", "playerAttributes": [{ "name": "monster-kills", "type": "number", "default": 5 }], "algorithm": { "balancedAttribute": "monster-kills", "strategy": "balanced", "batchingPreference": "fastestRegion" }, "teams": [{ "name": "Monsters", "maxPlayers": 5, "minPlayers": 5 }, { "name": "Hunters", "maxPlayers": 15, "minPlayers": 12, "quantity": 10 }], "rules": [{ "name": "latency-catchall", "description": "Sets maximum acceptable latency", "type": "latency", "maxLatency": 150 }], "expansions": [{ "target": "teams[Hunters].minPlayers", "steps": [{ "waitTimeSeconds": 15, "value": 10 }, {

Version185

Amazon GameLift Manuel du développeurConfiguration de la notification d'événement

"waitTimeSeconds": 20, "value": 8 }] }]}

Configuration de la notification FlexMatch d'événementSi vous utilisez l'activité de mise en relation FlexMatch dans votre jeu, vous avez besoin d'un moyende suivre l'état des demandes individuelles de mise en relation et de prendre les mesures appropriées.Parfois, comme lorsque des joueurs doivent accepter une proposition de mise en relation, ces actions sonturgentes. La mise en œuvre de notifications d'événements est une méthode rapide et efficace pour suivreles événements de mise en relation. Tous les jeux en production, ou en pré-production avec une activité demise en relation à volume élevé, doivent utiliser des notifications d'événement.

Il existe deux options pour configurer les notifications d'événement. Vous pouvez utiliserAmazon CloudWatch Events, qui dispose d'une suite d'outils disponibles pour gérer les événements etprendre des mesures adéquates. Autrement, vous pouvez configurer vos propres rubriques SNS et lesassocier à votre matchmaker pour recevoir les notifications d'événement de mise en relation directement.

Consultez la liste des événements FlexMatch émis par Amazon GameLift dans Événements FlexMatch demise en relation (p. 337).

Configurer CloudWatch EventsAmazon GameLift publie automatiquement tous les événements de mise en relation sur CloudWatchEvents. Avec CloudWatch Events vous pouvez configurer des règles pour que les événements de miseen relation soient acheminés vers un ensemble de cibles, dont les rubriques SNS et autres servicesAWS, en vue de leur traitement. Par exemple, vous pouvez définir une règle pour acheminer l'événement« PotentialMatchCreated » vers une fonction AWS Lambda qui gère les acceptations de joueurs. Pour ensavoir plus sur CloudWatch Events, consultez le Guide de démarrage, qui inclut un ensemble de tutoriels.

Si vous prévoyez d'utiliser votre CloudWatch Events lors de la configuration de vos matchmakers, vouspouvez laisser le champ cible de notification vide ou faire référence à une rubrique SNS si vous souhaitezutiliser les deux options.

Pour accéder aux événements de mise en relation Amazon GameLift dans CloudWatch Events, allez dansla console Amazon CloudWatch et ouvrez Événements. Assurez-vous d'être dans la région où vous avezdéfini votre configuration de mise en relation. Pour plus d'informations sur l'obtention des informationsd'identification du compte pour accéder à CloudWatch Events , consultez Connexion à la CloudWatchconsole Amazon. Chaque événement de mise en relation est identifié par le service (GameLift), le nom del'activité de mise en relation et le ticket de l'activité de mise en relation.

Configuration d'une rubrique SNSVous pouvez demander à Amazon GameLift de publier tous les événements générés par un matchmakerFlexMatch sur une rubrique Amazon Simple Notification Service (SNS). Lors de la configuration dumatchmaker, définissez le champ cible de notification avec l'ARN d'une rubrique SNS.

Pour configurer une rubrique SNS pour une notification d'événement Amazon GameLift

1. Accédez à la console Amazon Simple Notification Service.2. Créer une rubrique. Dans le tableau de bord SNS, choisissez Create topic (Créer une rubrique) et

suivez les instructions. Lorsque la rubrique est créée, la console ouvre automatiquement la page Topicdetails de la nouvelle rubrique.

3. Autorisez Amazon GameLift à publier dans la rubrique. Si vous n'êtes pas déjà sur la page Détails dela rubrique, choisissez Rubriques dans la barre de navigation et cliquez sur l'ARN de la rubrique pour

Version186

Amazon GameLift Manuel du développeurAppairage de VPC

l'ouvrir. Choisissez l'action de rubrique Modifier la politique de rubrique et accédez à l'onglet Affichageavancé.

Ajoutez la syntaxe en gras ci-dessous à la fin de votre politique existante. (La totalité de la politique estaffichée pour plus de clarté.)

{ "Version": "2008-10-17", "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" } ]}

Homologation VPC pour GameLiftCette rubrique fournit des conseils pour configurer une connexion d'appairage de VPC entre vos serveursde jeu hébergés par GameLift et vos autres ressources non-GameLift. Utilisez les connexions d'appairageAmazon Virtual Private Cloud (VPC) pour activer vos serveurs de jeux et communiquer directement et demanière privée avec vos autres ressources AWS, telles qu'un service web ou un référentiel. Vous pouvezétablir un appairage de VPC avec toutes les ressources qui s'exécutent sur AWS et qui sont gérées par uncompte AWS auquel vous avez accès.

Note

L'appairage de VPC est une fonction avancée. Découvrez d'autres options permettant à vosserveurs de jeux de communiquer directement et de manière privée avec vos autres ressourcesAWS dans Communiquez avec d’autres ressources AWS de vos flottes (p. 49).

Version187

Amazon GameLift Manuel du développeurPour configurer l'appairage de VPC pour une flotte existante

Si vous connaissez déjà les Amazon VPC et l'appairage de VPC, veuillez noter que la configuration del'appairage avec les serveurs de jeu GameLift est quelque peu différente. Vous n'avez pas accès auVPC pour vos serveurs de jeu (le contrôle est assuré par le service GameLift) et, par conséquent, vousne pouvez pas directement demander l'appairage de VPC. Au lieu de cela, vous devez d'abord pré-autoriser le VPC avec vos ressources non-GameLift à accepter une demande d'appairage provenant duservice GameLift. Ensuite, vous déclenchez GameLift pour demander l'appairage du VPC que vous venezd'autoriser. GameLift gère les tâches de création de la connexion d'appairage, de configuration des tablesde routage et de configuration de la connexion.

Pour configurer l'appairage de VPC pour une flotteexistante1. Obtenez les ID de compte AWS et les informations d'identification.

Vous avez besoin d'un ID et d'informations d'identification de connexion pour les comptes AWSsuivants. Vous pouvez trouver les ID de compte AWS en vous connectant à AWS ManagementConsole et en affichant les paramètres de votre compte. Pour obtenir les informations d'identification,accédez à la console IAM.

• Compte AWS que vous utilisez pour gérer vos serveurs de jeu GameLift.• Compte AWS que vous utilisez pour gérer vos ressources non-GameLift.

Si vous utilisez le même compte pour les ressources GameLift et non-GameLift, vous avez besoin d'unID et d'informations d'identification pour ce compte uniquement.

2. Obtenez les identifiants de chaque VPC.

Obtenez les informations suivantes pour les deux VPC à appairer :

• VPC pour vos serveurs de jeu GameLift – Il s'agit de votre ID de flotte GameLift. Vos serveurs dejeu sont déployés dans GameLift sur une flotte d'instances EC2. Chaque flotte est automatiquementplacée dans son propre VPC, qui est géré par le service GameLift. Vous ne disposez pas d'un accèsdirect au VPC, si bien qu'il est identifié par l'ID de flotte.

• VPC pour vos ressources AWS non-GameLift – Vous pouvez établir un appairage de VPC avectoutes les ressources qui s'exécutent sur AWS et qui sont gérées par un compte AWS auquel vousavez accès. Si vous n'avez pas déjà créé un VPC pour ces ressources, consultez Mise en routeavec Amazon VPC. Une fois que vous avez créé un VPC, vous pouvez trouver l'ID du VPC en vousconnectant à AWS Management Console pour Amazon VPC et en affichant vos VPC.

Note

Lorsque vous configurez un appairage, les deux VPC doivent exister dans la même région. LeVPC pour les serveurs de jeu de votre flotte GameLift se trouve dans la même région que laflotte.

3. Autorisez un appairage de VPC.

Au cours de cette étape, vous préautorisez une future demande GameLift d'appairer le VPC avec vosserveurs de jeux avec votre VPC pour les ressources GameLift non disponibles. Cette étape met à jourle groupe de sécurité pour votre VPC.

Pour autoriser l'appairage de VPC, appelez l'API de service GameLift CreateVpcPeeringAuthorization() ou utilisez la commande create-vpc-peering-authorizationde l'interface de ligne de commande AWS. Effectuez cet appel à l'aide du compte qui gère vosressources non-GameLift. Identifiez les informations suivantes :

Version188

Amazon GameLift Manuel du développeurPour configurer l'appairage de VPC avec une nouvelle flotte

• ID du VPC d'appairage – Il se rapporte au VPC avec vos ressources non-GameLift.• ID du compte AWS GameLift – Il s'agit du compte que vous utilisez pour gérer votre flotte GameLift.

Une fois que vous avez autorisé l'appairage d'un VPC, l'autorisation reste valable pendant 24 heuressauf révocation. Vous pouvez gérer vos autorisations d'appairage de VPC à l'aide des opérationssuivantes :

• DescribeVpcPeeringAuthorizations() (AWS CLI describe-vpc-peering-authorizations).• DeleteVpcPeeringAuthorization() (delete-vpc-peering-authorization dans l'interface de

ligne de commande AWS).4. Demandez une connexion d'appairage.

Avec une autorisation valide, vous pouvez demander qu'GameLift établisse une connexiond'appairage.

Pour demander un appairage de VPC, appelez l'API de service GameLiftCreateVpcPeeringConnection() ou utilisez la commande create-vpc-peering-connection del'interface de ligne de commande AWS. Effectuez cet appel à l'aide du compte qui gère vos serveursde jeu GameLift. Utilisez les informations suivantes pour identifier les deux VPC que vous souhaitezappairer :

• ID du VPC d'appairage et ID du compte AWS – Il s'agit du VPC utilisé pour vos ressources non-GameLift et du compte que vous utilisez pour les gérer. L'ID du VPC doit correspondre à celui d'uneautorisation d'appairage valide.

• ID de flotte – Il identifie le VPC utilisé pour vos serveurs de jeu GameLift.5. Suivez l'état de la connexion de l'appairage.

La demande d'une connexion d'appairage de VPC est une opération asynchrone. Pour suivrel'état d'une demande d'appairage et gérer les cas de réussite ou d'échec, utilisez l'une des optionssuivantes :

• Interrogez de façon continue avec DescribeVpcPeeringConnections(). Cette opérationrécupère l'enregistrement de connexion de l'appairage de VPC, y compris l'état de la demande.Si une connexion d'appairage est créée avec succès, l'enregistrement de la connexion contientégalement le bloc CIDR d'adresses IP privées attribué au VPC.

• Gérez les événements de flotte associés aux connexions d'appairage de VPC avecDescribeFleetEvents(), y compris les événements de réussite et de défaillance.

Une fois la connexion d'appairage établie, vous pouvez la gérer à l'aide des opérations suivantes :

• DescribeVpcPeeringConnections() (AWS CLI describe-vpc-peering-connections).• DeleteVpcPeeringConnection() (delete-vpc-peering-connection dans l'interface de ligne de

commande AWS).

Pour configurer l'appairage de VPC avec une nouvelleflotteVous pouvez créer une flotte GameLift et demander en même temps une connexion d'appairage de VPC.

Version189

Amazon GameLift Manuel du développeurPour configurer l'appairage de VPC avec une nouvelle flotte

1. Obtenez les ID de compte AWS et les informations d'identification.

Vous avez besoin d'un ID et d'informations d'identification de connexion pour les deux comptes AWSsuivants. Vous pouvez trouver les ID de compte AWS en vous connectant à AWS ManagementConsole et en affichant les paramètres de votre compte. Pour obtenir les informations d'identification,accédez à la console IAM.

• Compte AWS que vous utilisez pour gérer vos serveurs de jeu GameLift.• Compte AWS que vous utilisez pour gérer vos ressources non-GameLift.

Si vous utilisez le même compte pour les ressources GameLift et non-GameLift, vous avez besoin d'unID et d'informations d'identification pour ce compte uniquement.

2. Obtenez l'ID de VPC pour vos ressources AWS non-GameLift.

Si vous n'avez pas encore créé de VPC pour ces ressources, faites-le maintenant (voir Mise en routeavec Amazon VPC). Veillez à créer le nouveau VPC dans la région où vous prévoyez de créer votrenouvelle flotte. Si vos ressources autres que les ressources GameLift sont gérées sous un compteAWS ou un groupe d'utilisateurs/utilisateurs différents de celui avec lequel vous utilisez GameLift, vousdevrez utiliser ces informations d'identification de compte lors de la demande d'autorisation à l'étapesuivante.

Une fois que vous avez créé un VPC, vous pouvez localiser l'ID du VPC dans la console Amazon VPCen affichant vos VPC.

3. Autorisez un appairage de VPC avec les ressources non-GameLift.

Quand GameLift crée la flotte et le VPC correspondant, il envoie également une demande d'appairageavec le VPC pour vos ressources autres que les ressources GameLift. Vous devez pré-autoriser cettedemande. Cette étape met à jour le groupe de sécurité pour votre VPC.

À l'aide des informations d'identification du compte qui gère vos ressources non-GameLift, appelezl'API de service GameLift CreateVpcPeeringAuthorization() ou utilisez la commande create-vpc-peering-authorization de l'interface de ligne de commande AWS. Identifiez les informationssuivantes :

• ID du VPC d'appairage – ID du VPC utilisé avec vos ressources non-GameLift.• ID du compte AWS GameLift – ID pour le compte que vous utilisez pour gérer votre flotte GameLift.

Une fois que vous avez autorisé l'appairage d'un VPC, l'autorisation reste valable pendant 24 heuressauf révocation. Vous pouvez gérer vos autorisations d'appairage de VPC à l'aide des opérationssuivantes :

• DescribeVpcPeeringAuthorizations() (AWS CLI describe-vpc-peering-authorizations).• DeleteVpcPeeringAuthorization() (delete-vpc-peering-authorization dans l'interface de

ligne de commande AWS).4. Suivez les instructions pour la création d'une flotte avec l'interface de ligne de commande

AWS (p. 116). Incluez les paramètres requis supplémentaires suivants :

• peer-vpc-aws-account-id – ID pour le compte que vous utilisez pour gérer le VPC avec vosressources non-GameLift.

• peer-vpc-id – ID du VPC utilisé avec votre compte non-GameLift.

Un appel réussi à create-fleet avec les paramètres d'appairage de VPC génère à la fois une nouvelle flotteet une nouvelle demande d'appairage de VPC. Le statut de la flotte est défini sur New et le processusd'activation de la flotte est initié. Le statut de la demande d'appairage est défini sur initiating-request.

Version190

Amazon GameLift Manuel du développeurRésolution des problèmes d'appairage de VPC

Vous pouvez suivre la réussite ou l'échec de la demande d'appairage en appelant describe-vpc-peering-connections.

Lorsque vous demandez une connexion d'appairage de VPC avec une nouvelle flotte, les deux actionsaboutissent ou échouent. Si une flotte échoue pendant le processus de création, la connexion d'appairagede VPC n'est pas établie. De même, si une connexion d'appairage de VPC échoue pour une raisonquelconque, la nouvelle flotte ne peut pas passer du statut Activating au statut Active.

Note

La nouvelle connexion d'appairage de VPC n'est pas terminée tant que la flotte n'est pas prête àêtre active. Cela signifie que la connexion n'est pas disponible et ne peut pas être utilisée pendantle processus d'installation du serveur de jeu.

L'exemple suivant crée à la fois une nouvelle flotte et une connexion d'appairage entre un VPC préétabli etle VPC de la nouvelle flotte. Le VPC prédéfini est identifié de manière unique par la combinaison de l'ID devotre compte AWS non GameLift et l'ID du VPC.

$ aws gamelift create-fleet --name "My_Fleet_1" --description "The sample test fleet" --ec2-instance-type "c5.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"

Version 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 "c5.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" --peer-vpc-aws-account-id "111122223333" --peer-vpc-id "vpc-a11a11a"

Résolution des problèmes d'appairage de VPCSi vous rencontrez des difficultés pour établir une connexion d'appairage VPC pour vos serveurs de jeuxGameLift, tenez compte des causes racine suivantes :

• Une autorisation pour la connexion demandée est introuvable.

Version191

Amazon GameLift Manuel du développeurRésolution des problèmes d'appairage de VPC

• Vérifiez l'état d'une autorisation VPC pour le VPC non-GameLift. Il se peut qu'il n'existe pas ou qu'il aitexpiré.

• Vérifiez les régions des deux VPC que vous essayez d'appairer. S'ils ne sont pas dans la mêmerégion, ils ne peuvent pas être appairés.

• Les blocs CIDR (voir Configurations de connexion d'appairage de VPC non valides) de vos deux VPCse chevauchent. Les blocs CIDR IPv4 affectés aux VPC appairés ne peuvent pas se chevaucher. Lebloc d'adresses CIDR du VPC de votre flotte GameLift est automatiquement attribué et ne peut pasêtre modifié. Vous devrez donc modifier le bloc CIDR du VPC pour vos ressources non-GameLift. Pourrésoudre ce problème :• Recherchez ce bloc d'adresses CIDR pour votre flotte GameLift en appelantDescribeVpcPeeringConnections().

• Accédez à la console Amazon VPC, recherchez le VPC correspondant à vos ressources non-GameLiftet modifiez le bloc d'adresses CIDR afin qu'ils ne se chevauchent pas.

• La nouvelle flotte ne s'est pas activée (lors de la demande d'appairage VPC avec une nouvelle flotte). Sila nouvelle flotte n'a pas réussi à passer au statut Actif, il n'y a pas de VPC à appairer, de sorte que laconnexion d'appairage ne peut pas réussir.

Version192

Amazon GameLift Manuel du développeurAffichage de l'état actuel d'GameLift

Affichage de vos données de jeu surla console

Le service GameLift géré collecte en permanence les données des jeux actifs pour vous aider àcomprendre le comportement et les performances des joueurs. Avec la console Amazon GameLift, vouspouvez afficher, gérer et analyser ces informations pour vos versions de génération, flottes et sessions dejeu et de joueur.

Rubriques• Affichage de l'état actuel d'Amazon GameLift (p. 193)• Affichage de vos versions de génération (p. 194)• Affichage de vos flottes (p. 195)• Affichage des détails d'une flotte (p. 196)• Affichage des données sur les sessions de jeu et les sessions de joueur (p. 199)• Affichage de vos alias (p. 201)

Affichage de l'état actuel d'Amazon GameLiftLe tableau de bord fournit une vue grille comportant les éléments suivants :

• Versions• Flottes dans tous les états• Alias créés et flottes qu'ils indiquent (le cas échéant)

Pour ouvrir le tableau de bord d'Amazon GameLift

• Dans la console Amazon GameLift, choisissez Tableau de bord dans la barre de menu.

Depuis le tableau de bord, vous pouvez effectuer les actions suivantes :

• Afficher les relations entre des éléments. Cliquez n'importe où dans une zone d'élément afin d'afficherles relations entre cet élément et d'autres sur le tableau de bord. Par exemple, cliquez sur une versionde génération pour afficher toutes les flottes qui ont été créées avec cette version. Cliquez sur une flottepour voir la version de génération avec laquelle elle a été créée et l'alias sur lequel elle pointe. Pourréinitialiser le tableau de bord, cliquez sur le bouton Reset overview.

• Afficher les détails sur une version de génération, une flotte ou un alias. Cliquez sur le numérod'identification d'un élément pour ouvrir la page des détails.

Version193

Amazon GameLift Manuel du développeurAffichage de vos versions de génération

Affichage de vos versions de générationVous pouvez afficher des informations sur toutes les versions de génération du serveur de jeux que vousavez chargées dans Amazon GameLift et leur appliquer des actions. Les versions de génération affichéesincluent uniquement celles qui sont chargées pour la région sélectionnée.

Catalogue des versions de générationLes versions de génération chargées sont affichées sur la page Builds. Pour consulter cette page,choisissez Builds dans la barre de menus de la console Amazon GameLift.

La page Builds fournit les informations récapitulative suivantes pour toutes les versions de génération :

• Statut – Affiche l'un des trois messages de statut possibles :• Initialisé – La build a été créée, mais le chargement n'est pas encore démarré ou il est encore en

cours.• Prêt – La build a été reçue et elle est prête pour la création de la flotte.• Échec – La build a expiré avant que les binaires ne soient reçus.

• Nom de build – Nom associé à la build chargée. Un nom de build est fourni lors du chargement de cettedernière dans Amazon GameLift, et il peut être modifié à l'aide de l'action du kit AWS SDK UpdateBuild.

• ID de génération – ID unique affecté à la build lors du chargement.• Version – Libellé de version associé à la build chargée. Un nom de build est fourni lors du chargement

de cette dernière dans Amazon GameLift, et il peut être modifié à l'aide de l'action du kit AWS SDKUpdateBuild.

• Système d'exploitation – Système d'exploitation sur lequel s'exécute la build. Le système d'exploitationde la version de génération détermine le système d'exploitation qui est installé sur les instances d'uneflotte.

• Taille – Taille, en mégaoctets (Mo), du fichier de la build chargée dans Amazon GameLift.• Date de création – Date et heure auxquelles la build a été chargée dans Amazon GameLift.• Flottes – Nombre de flottes actuellement déployées avec cette build.

À partir de cette page, vous pouvez effectuer l'une des opérations suivantes :

Version194

Amazon GameLift Manuel du développeurDétails de version de génération

• Créer une nouvelle flotte à partir d'une version de génération. Sélectionnez une version de génération etcliquez sur Create fleet from build.

• Supprimer une build. Sélectionnez une build et cliquez sur Suppression d'une build.• Filtrer et trier la liste de versions de génération. Utiliser les commandes situées dans la partie supérieure

tableau.• Consulter les détails d'une version de génération. Cliquez sur un nom de version de génération pour

ouvrir la pages des détails associée.

Détails de version de générationAccédez à la page des détails depuis le tableau de bord de la console ou la page Builds en cliquant sur lenom de la version de génération. La page des détails Build affiche les mêmes informations récapitulativesde version de génération que la page Builds. Elle affiche également une liste des flottes créées avec laversion de génération. Cette liste constitue essentiellement le catalogue de flottes, filtrées par version degénération. Elle inclut les mêmes informations récapitulative que la page Builds (p. 195).

Affichage de vos flottesVous pouvez voir les informations sur tous les flottes créées pour l'hébergement de vos jeux surAmazon GameLift sous votre compte AWS. Seules sont affichées les flottes qui ont été créées dansla région sélectionnée. À partir de la page Flottes, vous pouvez créer une flotte ou afficher des détailssupplémentaires sur une flotte sélectionnée. La page des détails (p. 196) d'une flotte contient desinformations d'utilisation et des métriques, ainsi que les données de jeu et de session de joueur. Vouspouvez également modifier un enregistrement de flotte ou suspendre la flotte.

Pour afficher la page Flottes, choisissez Flottes dans la barre de menus de la console Amazon GameLift.

La page Flottes affiche les informations récapitulatives suivantes par défaut : Vous pouvez personnaliserles informations à afficher en utilisant le bouton Paramètres (engrenage).

• Statut – Statut de la flotte. Les possibles sont : Nouveau, Téléchargement en cours, Création et Actif.Une flotte doit être à l'état Active pour pouvoir héberger des sessions de jeu et autoriser des connexionsjoueur.

• Nom de la flotte – Nom convivial affecté à la flotte.• Type EC2 – Type d'instance Amazon EC2 qui détermine la capacité de calcul des instances d'une flotte.• Système d'exploitation – Système d'exploitation sur chacune des instances de la flotte. Le système

d'exploitation d'une flotte est déterminé par la version de génération déployée sur celle-ci.• Instances actives – Nombre d'instances EC2 en cours d'utilisation pour la flotte.• Instances maximum – Nombre maximal actuel d'instances EC2 autorisées sur la flotte. Cette valeur est

configurable (dans les limites du service) à partir de la page Détails de la flotte, onglet Dimensionnement.• Sessions de jeu – Nombre de sessions de jeu actives en cours d'exécution dans la flotte. Les données

sont retardées de cinq minutes.• Sessions de joueur – Nombre de joueurs connectés aux sessions de jeu dans la flotte. Les données sont

retardées de cinq minutes.• Durée opérationnelle – Durée totale d'exécution de la flotte.• Date de création – Date et heure de création de la flotte.

Version195

Amazon GameLift Manuel du développeurAffichage des détails d'une flotte

Affichage des détails d'une flotteVous pouvez accéder aux informations détaillées d'une flotte, y compris aux paramètres de configuration,paramètres de dimensionnement, métriques, données de jeu et de joueur. Accédez à la page des détailsd'une flotte depuis le tableau de bord de la console ou la page Fleets en cliquant sur le nom de la flotte.

Cette page vous permet également d'effectuer les actions suivantes :

• Mettre à jour les métadonnées et la configuration d'exécution de la flotte. Choisissez Actions: Edit fleet.• Modifier les paramètres de capacité de la flotte. Sur la page Dimensionnement, modifiez les nombres

d'instances Minimum et Maximum, ou définissez manuellement une taille fixe pour la capacité de flotteSouhaitée.

• Définissez ou modifiez les stratégies de scalabilité automatique. Sur la page Dimensionnement, activezou désactivez la scalabilité automatique.

• Arrêter une flotte. Choisissez Actions: Terminate fleet.

Récapitulatif de la flotteLe tableau récapitulatif comprend les informations suivantes :

• Statut – État actuel de la flotte, qui peut avoir pour valeur Nouveau, Téléchargement en cours, Créationet Active. Une flotte doit être active pour pouvoir héberger des sessions de jeu ou accepter desconnexions de joueur.

• ID de flotte – Identificateur unique affecté à la flotte.• Système d'exploitation – Système d'exploitation sur chacune des instances de la flotte. Le système

d'exploitation d'une flotte est déterminé par la version de génération déployée sur celle-ci.• Type de flotte – Indique si la flotte utilise des instances à la demande ou des instances Spot.• Type EC2 – Type d'instance Amazon EC2 sélectionné pour la flotte lors de sa création. Le type

d'instance d'une flotte indique le matériel informatique et la capacité utilisés pour chaque instance de laflotte et détermine les limites de l'instance pour la flotte.

• Instances actives – Nombre d'instances dont l'état est Actif, ce qui signifie qu'elles exécutentactuellement des sessions de jeu ou qu'elles sont prêtes à en exécuter.

• Serveurs actifs – Nombre de processus serveur actuellement à l'état Actif dans la flotte. Les donnéessont retardées de cinq minutes.

• Sessions de jeu – Nombre de sessions de jeu actives en cours d'exécution sur des instances de la flotte.Les données sont retardées de cinq minutes.

• Sessions de joueur – Nombre de joueurs actuellement connectés et nombre total d'emplacements dejoueur dans les sessions de jeu actives au sein de la flotte. Exemple : 25 (joueurs connectés) sur 100(joueurs possible) signifie que la flotte peut prendre en charge 75 joueurs supplémentaires. Les donnéessont retardées de cinq minutes.

• Protection – Paramètre actuel de protection de session de jeu (p. 6) pour la flotte.

Durée opérationnelle – Durée totale pendant laquelle la flotte a été active.• Date de création – Date et heure de création de la flotte.

MétriquesL'onglet Métriques affiche une représentation graphique des métriques d'une flotte dans le temps. Pourafficher les métriques avec Amazon CloudWatch, consultez Surveiller GameLift avec Amazon CloudWatch (p. 202).

Version196

Amazon GameLift Manuel du développeurÉvénements

Pour afficher les informations de métriques dans le graphique

1. Dans la liste à gauche de la zone de graphique, cliquez sur un nom de métrique afin de l'ajouter àl'affichage graphique. Les noms de métrique qui sont grisés ne sont pas représentés graphiquementactuellement. Le code couleur identifie les lignes qui correspondent à chaque métrique représentéegraphiquement. Les descriptions des métriques individuelles sont disponibles à l'adresse MétriquesGameLift pour les flottes (p. 202). Les catégories de métriques suivantes sont disponibles :

• Nombres d'instances – Ces métriques suivent les modifications dans le temps en termes de capacitéet d'utilisation au niveau de l'instance (également affichées sous l'onglet Dimensionnement).

• Jeu – Ces métriques montrent l'activité et l'utilisation de la flotte au fil du temps au niveau de lasession de jeu.

• Processus serveur – Ces métriques suivent l'état et le statut des processus serveur au sein de laflotte. Le service Amazon GameLift interroge régulièrement l'état de chacun des processus serveuractifs.

• Performance de l'instance – Ces métriques indiquent les performances des ressourcesinformatiques de la flotte. Consultez les descriptions détaillées de chaque métrique dans Métriquesdes instances EC2.

2. Utilisez les filtres suivants, affichés au-dessus de la zone de graphique, pour modifier le moded'affichage des données des métriques :

• Données et Période – Propose deux options pour la sélection d'une plage de dates :• Utilisez Relative pour sélectionner une période relative à l'heure en cours, par exemple Last hour,

Last day, Last week.• Utilisez Absolute pour indiquer une période avec une date/heure de début et de fin arbitraire.

• Granularité – Sélectionnez une durée pour l'agrégation des points de données.• Taux de rafraîchissement – Sélectionnez la fréquence de mise à jour de l'affichage du graphique.• Fuseau horaire – Sélectionnez le format d'heure à utiliser dans l'affichage du graphique : UTC

(temps universel coordonné) ou Browser time (Heure du navigateur) (heure locale).• Afficher les points – Activez ou désactivez l'affichage de points de données discrets (comme des

cercles) ou l'affichage de lignes uniquement.

ÉvénementsL'onglet Events comporte un journal de tous les événements qui se sont produits sur la flotte, avec le coded'événement, le message et l'horodatage. Consultez les descriptions des événements dans le Référenced'API Amazon GameLift.

Mise à l'échelleL'onglet Scaling contient des informations relatives à la capacité de la flotte, dont l'état actuel et unereprésentation graphique des modifications de capacité dans le temps. Il propose aussi des outils pour lamise à jour des limites de capacité et la gestion de la scalabilité automatique.

Pour afficher les informations actuelles et historiques de dimensionnement

1. Rendez-vous sur le haut de l'onglet Scaling. L'état de capacité en cours de ce parc est affiché dans lacolonne de gauche. Ces valeurs sont définies comme suit :

• Limites de dimensionnement – Ces métriques suivent l'historique des modifications apportées auxlimites de capacité.

Version197

Amazon GameLift Manuel du développeurSessions de jeu

• Minimum – Limite inférieure stricte concernant le nombre d'instances à conserver dans la flotte.La capacité du parc ne passe pas au dessous du minimum actuel pendant une scalabilitéautomatique ou même si la capacité souhaitée est définie en dessous du minimum.

• Souhaitée – Nombre d'instances actives actuellement souhaité dans la flotte. L'objectif est defaire correspondre le nombre d'instances à l'état Active (décrit plus loin) au nombre d'instancessouhaitées ; il y parvient en créant ou en mettant hors service des instances en fonction desbesoins.

• Maximum – Limite supérieure stricte concernant le nombre d'instances à conserver dans la flotte.la capacité du parc ne doit pas dépasser la valeur maximum actuelle pendant une scalabilitéautomatique ou si la capacité souhaitée est définie au-dessus du maximum.

• Nombres d'instances et Jeu – Ces métriques suivent les modifications réelles en termes de capacitéet d'utilisation dans le temps. Consultez les descriptions des métriques individuelles à l'adresseMétriques GameLift pour les flottes (p. 202).

Pour voir l'évolution de capacité de la flotte au fil du temps, affichez dans le graphique tout ou partiedes métriques de dimensionnement figurant sur la gauche. Cliquez sur le nom de métrique à ajouterau graphique. (Les noms de métriques sont gris lorsqu'ils ne sont pas en cours d'utilisation.) Utilisez lecode couleur pour identifier les lignes de graphique qui correspondent à une métrique sélectionnée.

2. Utilisez les filtres suivants, indiqués au-dessus de la zone de graphique, pour spécifier le moded'affichage des métriques dans le graphique :

• Données et Période – Propose deux options pour la sélection d'une plage de dates :• Utilisez Relative pour sélectionner une période relative à l'heure en cours, par exemple Last hour,

Last day, Last week.• Utilisez Absolute pour indiquer une période avec une date/heure de début et de fin arbitraire.

• Granularité – Sélectionnez une durée pour l'agrégation des points de données.• Taux de rafraîchissement – Sélectionnez la fréquence de mise à jour de l'affichage du graphique.• Format – Sélectionnez le format d'heure à utiliser dans l'affichage du graphique : UTC (temps

universel coordonné) ou Browser time (Heure du navigateur) (heure locale).• Afficher les points – Activez ou désactivez l'affichage de points de données discrets (comme des

cercles) ou l'affichage de lignes uniquement.

Pour modifier la capacité d'une flotte

• Au-dessous du graphique de l'historique figurent les outils permettant de définir les limites decapacité et la capacité de dimensionnement. Consultez Réglage manuel de la capacité d'une flotteGameLift (p. 135) pour plus de détails sur l'utilisation de ces outils. Pour plus d'informations sur lagestion de la scalabilité automatique, consultez Dimensionner automatiquement la capacité de la flotteavec GameLift (p. 137).

Sessions de jeuL'onglet Game sessions affiche la liste des sessions de jeu passées et présentes hébergées dansla flotte, y compris certaines informations détaillées. Cliquez sur un ID de session de jeu pouraccéder aux informations de session de jeu supplémentaires, y compris les sessions de joueur. Pourplus d'informations, consultez Affichage des données sur les sessions de jeu et les sessions dejoueur (p. 199).

Version198

Amazon GameLift Manuel du développeurAllocation de capacité

Allocation de capacitéL'onglet Allocation de capacité affiche la configuration d'exécution de la flotte, qui indique les processusserveur à lancer sur chaque instance et comment les lancer. Il inclut le chemin d'accès à l'exécutabledu serveur de jeux et des paramètres de lancement en option. Vous pouvez modifier l'allocation decapacité de la flotte en modifiant la flotte dans la console ou en utilisant l'AWS CLI afin de mettre à jour laconfiguration d'exécution.

PortsL'onglet Ports affiche les autorisations de connexion de la flotte, y compris l'adresse IP et les plages deport. Vous pouvez modifier les autorisations de connexion, en éditant la flotte sur la console ou à l'aide del'interface AWS CLI pour mettre à jour les paramètres de port de la flotte.

BuildL'onglet Build affiche la configuration liée à la version de génération de la flotte, laquelle a été définie lorsde la création de la flotte. Sélectionnez l'ID de version de génération afin de voir la page des détails de laversion de génération complète.

Si votre version de génération a été supprimée ou si une erreur s'est produite lors d'une tentative derécupération de votre version de génération, vous pouvez voir l'un des messages d'état suivants :

• Deleted (Supprimée) – La build de cette flotte a été supprimée. Votre flotte s'exécutera correctementmême si la version de génération a été supprimée.

• Erreur – Une erreur s'est produite lors d'une tentative de récupération des informations de build pour laflotte.

ARNL'onglet ARNs (ARN) affiche l'Amazon Resource Name (ARN) associé à cette flotte :

• Fleet ARN (ARN de la flotte) – Identifiant unique affecté à cette flotte. L'ARN d'une flotte identifie celle-ci en tant que ressource Amazon GameLift, et spécifie la région et le compte AWS, pour s'assurer qu'ils'agit d'un identifiant unique.

• Instance Role ARN (ARN du rôle d'instance) – Identifiant d'un rôle IAM AWS qui gère l'accès à vos autresressources AWS, si celui-ci a été fourni lors de la création de la flotte. Lorsqu'un ARN de rôle est associéà la flotte, les serveurs de jeux et les autres applications qui s'exécutent sur la flotte peuvent accéder àces autres ressources AWS. Découvrez-en plus sur Communiquez avec d’autres ressources AWS devos flottes (p. 49).

Affichage des données sur les sessions de jeu etles sessions de joueur

Vous pouvez afficher les informations relatives aux jeux en cours d'exécution sur une flotte ainsi qu'auxjoueurs individuels. Pour plus d'informations sur les sessions de jeu et les sessions de joueur, consultezComment les joueurs se connectent aux Jeux (p. 13).

Pour afficher les données de session de jeu

1. Dans la console Amazon GameLift, ouvrez la page des détails de la flotte que vous voulez étudier.(Choisissez Fleets dans la barre de menus et cliquez sur un nom de flotte.)

Version199

Amazon GameLift Manuel du développeurSessions de jeu

2. Ouvrez l'onglet Game sessions . Cet onglet répertorie toutes les sessions de jeu hébergées sur laflotte ainsi que des informations récapitulatives.

3. Cliquez sur une session de jeu pour voir des informations supplémentaires sur la session de jeu ainsique la liste des joueurs qui se sont connectés au jeu.

Sessions de jeuUn récapitulatif des informations de votre session de jeu s'affiche en haut de la page. Il inclut :

• Statut – Statut de la session de jeu. Les états valides sont les suivants :• Activation – Une session de jeu a été initiée et se prépare à être exécutée.• Active – Une session de jeu est en cours d'exécution et est disponible pour la réception de nouveaux

joueurs (en fonction de la stratégie de création de joueurs de la session).• Résilié – La session de jeu s'est terminée.

• Nom – Jeu généré pour la session de jeu.• ID – Identificateur unique assigné par Amazon GameLift à la session de jeu.• Adresse IP – Adresse IP spécifiée pour la session de jeu.• Port – Numéro de port utilisé pour la connexion à la session de jeu.• Sessions de joueur – Nombre de joueurs connectés aux sessions de jeu et nombre total de joueurs

pouvant être pris en charge par la session de jeu. Exemple : 2 (joueurs connectés) sur 10 (joueurspossible) signifie que la flotte peut prendre en charge 8 joueurs supplémentaires.

• Durée opérationnelle – Durée totale d'exécution de la session de jeu.• Date de création – Date et heure de création de la flotte.

Sessions de joueurLes données de session de joueur suivantes sont collectées pour chaque session de jeu :

• Statut – Statut de la session de joueur. Les options incluent :• Instances réservées – La session de joueur a été réservée, mais le joueur n'est pas encore connecté.• Active – La session de joueur est actuellement connectée au serveur de jeux.• Terminé – La session de joueur s'est terminée ; le joueur n'est plus connecté.• Expiré – La session de joueur a été réservée, mais le joueur n'a pas pu se connecter.

• ID – Identificateur affecté à la session de joueur.• ID de joueur – Identificateur unique du joueur. Cliquez sur cet ID pour obtenir des informations de joueur

supplémentaires.• Heure de début – Heure à laquelle le joueur s'est connecté à la session de jeu.• Heure de fin – Heure à laquelle le joueur s'est déconnecté de la session de jeu.• Durée totale – Durée totale pendant laquelle le joueur a été actif dans la session de joueur.

Informations sur le joueurAffichez des informations supplémentaires pour un joueur sélectionné, y compris une liste de tous les jeuxauxquels un joueur est connecté sur toutes les flottes de la région actuelle. Ces informations incluent lestatut, les heures de début et de fin, ainsi que le temps de connexion total pour chaque session de joueur.Vous pouvez cliquer pour afficher les données pertinentes relatives aux sessions de jeu et flottes.

Version200

Amazon GameLift Manuel du développeurAffichage de vos alias

Affichage de vos aliasVous pouvez voir les informations sur l'ensemble des alias de flotte que vous avez créés et leur appliquerdes actions depuis la page Aliases. Seuls sont affichés les alias créés pour la région sélectionnée.

Catalogue des aliasTous les alias créés sont affichés sur la page de catalogue des alias. Pour afficher la page Alias, choisissezAlias dans la barre de menus de la console Amazon GameLift.

La page Aliases comporte des informations récapitulative sur toutes les versions de génération, y comprisleur type. À partir de cette page, vous pouvez :

• Créez un nouvel alias. Cliquez sur Créer un alias.• Filtrer et trier la liste d'alias. Utiliser les commandes situées dans la partie supérieure tableau.• Afficher des informations sur les alias. Cliquez sur un nom d'alias pour ouvrir la page des détails

correspondante.

Détails des aliasVous pouvez accéder à page des détails d'un alias à partir du tableau de bord de la console ou de la pagede catalogue Aliases en cliquant sur le nom d'alias. La page des détails d'alias affiche un récapitulatif desinformations sur l'alias.

À partir de cette page, vous pouvez :

• Modifier un alias, y compris changer son nom, sa description et l'ID flotte auquel cet alias est associé.Cliquez sur Actions: Edit alias.

• Afficher les informations sur la flotte à laquelle l'alias est actuellement associé. Ces informationsconcernent l'état de la flotte et son utilisation actuelle (sessions de jeu et joueurs actifs).

• Supprimer un alias. Cliquez sur Actions: Delete alias.

Les informations détaillées d'alias sont les suivantes :

• Type – Options de routage possibles pour l'alias :• Simple – Un alias simple achemine un joueur jusqu'aux jeux d'une flotte associée. Vous pouvez mettre

à jour l'alias afin qu'il pointe sur une autre flotte à tout moment.• Terminal – Un alias de terminal ne pointe pas sur une flotte. Au lieu de cela, l'alias retransmet un

message au client. Ce type d'alias est utile pour informer correctement les joueurs lorsqu'un ensemblede serveurs de jeux n'est plus disponible. Par exemple, un alias terminal peut informer les joueurs queleurs clients de jeu sont obsolètes et proposer des options de mise à niveau.

• ID de l'alias – Numéro unique utilisé pour identifier l'alias.• Description – Description de l'alias.• Date de création – Date et heure de création de l'alias.

Version201

Amazon GameLift Manuel du développeurSurveillance avec CloudWatch

Surveillance d'Amazon GameLiftSi vous utilisez GameLift FleetIQ comme fonction autonome avec Amazon EC2, veuillez égalementconsulter Sécurité dans Amazon EC2 dans le Amazon EC2 Guide de l'utilisateur pour les instances Linux.

La surveillance est un enjeu important pour assurer la fiabilité, la disponibilité et les performancesd'Amazon GameLift et de vos autres solutions AWS. Les métriques sont utilisées avec Amazon GameLiftpour trois raisons principales : pour surveiller l'état du système et configurer des alarmes, pour suivreles performances et l'utilisation du serveur de jeux, et pour gérer la capacité à l'aide de la scalabilitéautomatique ou manuelle.

AWS fournit les outils de surveillance suivants pour contrôler Amazon GameLift, signaler les problèmes etdéclencher des actions automatiques, si nécessaire :

• Console Amazon GameLift• Amazon CloudWatch – Vous pouvez surveiller les métriques Amazon GameLift en temps réel, ainsi que

les métriques pour d'autres ressources et applications AWS que vous exécutez sur les services AWS.CloudWatch propose un ensemble de fonctions de surveillance, y compris des outils pour créer destableaux de bord personnalisés et la possibilité de définir des alarmes qui envoient un avertissement oudéclenchent des actions lorsqu'une métrique atteint un seuil spécifié.

• AWS CloudTrail – Capture tous les appels d'API et événements liés exécutés par ou pour votre compteAWS pour Amazon GameLift et d'autres services AWS. Les données sont envoyées en tant que fichiersjournaux à un compartiment Amazon S3 que vous spécifiez. Vous pouvez identifier les utilisateurs etles comptes qui ont appelé AWS, l'adresse IP source d'origine des appels, ainsi que le moment où lesappels ont eu lieu.

Rubriques• Surveiller GameLift avec Amazon CloudWatch (p. 202)• Journalisation des appels d'API Amazon GameLift avec AWS CloudTrail (p. 215)

Surveiller GameLift avec Amazon CloudWatchVous pouvez surveiller GameLift avec Amazon CloudWatch, service AWS qui recueille et traite les donnéesbrutes en métriques lisibles et disponibles presque en temps réel. Ces statistiques sont conservéespendant 15 mois pour fournir une perspective historique sur la performance de votre serveur de jeux avecGameLift. Vous pouvez définir des alarmes qui surveillent certains seuils et envoient des notificationsou effectuent des actions spécifiques lorsque ces seuils sont atteints. Pour de plus amples informations,veuillez consulter Guide de l'utilisateur Amazon CloudWatch.

Les tableaux suivants répertorient les métriques et les dimensions d'GameLift. Toutes les métriques quisont disponibles dans CloudWatch sont également disponibles dans la console GameLift, qui fournit lesdonnées sous la forme d'un ensemble de graphiques personnalisables. Pour accéder aux métriquesCloudWatch de vos jeux, vous pouvez utiliser AWS Management Console, l'AWS CLI ou l'API CloudWatch.

Métriques GameLift pour les flottesL'espace de nom AWS/GameLift inclut les métriques suivantes associées à une activité sur un parc ou ungroupe de parcs. Les flottes sont utilisées avec une solution GameLift gérée. Le service GameLift envoieles métriques suivantes à CloudWatch toutes les minutes.

Version202

Amazon GameLift Manuel du développeurMétriques GameLift pour les flottes

Instances

Métrique Description :

ActiveInstances Instances avec l'état ACTIVE, ce qui signifie qu'ellesexécutent des processus serveur actifs. Le compte inclutdes instances inactives et celles qui hébergent une ouplusieurs sessions de jeu. Cette métrique mesure lacapacité totale actuelle de l'instance. Cette métrique peutêtre utilisée avec le dimensionnement automatique.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum

DesiredInstances Nombre cible d'instances actives gérées par GameLiftdans la flotte. Grâce au dimensionnement automatique,cette valeur est déterminée en fonction des stratégiesde dimensionnement en vigueur actuellement. Sansdimensionnement automatique, cette valeur est définiemanuellement. Cette métrique n'est pas disponiblelorsque vous affichez les données pour les groupes demétriques du parc.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum

IdleInstances Instances actives qui hébergent actuellement zéro(0) session de jeu. Cette métrique mesure la capacitédisponible mais non utilisée. Cette métrique peut êtreutilisée avec le dimensionnement automatique.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum

MaxInstances Nombre maximal d'instances autorisées pour le parc.Le nombre maximal d'instances d'un parc déterminele plafond de capacité lors du dimensionnement à lahausse manuel ou automatique. Cette métrique n'est pasdisponible lorsque vous affichez les données pour lesgroupes de métriques du parc.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum

MinInstances Nombre minimal d'instances autorisées pour le parc. Lenombre minimal d'instances d'une flotte détermine leplancher de capacité lors de la réduction manuelle ouautomatique de la capacité. Cette métrique n'est pasdisponible lorsque vous affichez les données pour lesgroupes de métriques du parc.

Version203

Amazon GameLift Manuel du développeurMétriques GameLift pour les flottes

Métrique Description :Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum

PercentIdleInstances Pourcentage d'instances actives qui sont inactives(calculé selon la formule IdleInstances /ActiveInstances). Cette métrique peut être utiliséedans le cadre d'un dimensionnement automatique.

Unités Pourcentage

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum

InstanceInterruptions Nombre d'instances Spot qui ont été interrompues.

Unités Count

Statistiques CloudWatch pertinentes : Somme, Moyenne,Minimum, Maximum

Processus serveur

Métrique Description :

ActiveServerProcesses Processus serveur avec l'état ACTIVE, ce qui signifiequ'ils fonctionnent et sont en mesure d'héberger dessessions de jeu. Le compte inclut des processus serveurinactifs et ceux qui hébergent des sessions de jeu. Cettemétrique mesure la capacité totale actuelle de processusserveur.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum

HealthyServerProcesses Processus serveur actifs signalés comme sains. Cettemétrique est utile pour le suivi de la santé générale desserveurs de jeu du parc.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum

PercentHealthyServerProcesses Pourcentage de l'ensemble des processusserveur actifs signalés comme sains (calculéselon la formule HealthyServerProcesses /ActiveServerProcesses).

Unités Pourcentage

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum

Version204

Amazon GameLift Manuel du développeurMétriques GameLift pour les flottes

Métrique Description :

ServerProcessAbnormalTerminations Processus serveur ayant été arrêtés en raison decirconstances anormales depuis le dernier rapport.Cette métrique inclut les mises hors service initiéespar le service GameLift. Ces dernières surviennentlorsqu'un processus serveur cesse de répondre, signalerégulièrement des échecs de vérifications de l'état oun'est pas mis hors service correctement (en appelantProcessEnding()).

Unités Count

Statistiques CloudWatch pertinentes : Somme, Moyenne,Minimum, Maximum

ServerProcessActivations Processus serveur passés avec succès de l'étatACTIVATING à l'état ACTIVE depuis le dernier rapport.Les processus serveur ne peuvent pas héberger desessions de jeu tant qu'ils ne sont pas actifs.

Unités Count

Statistiques CloudWatch pertinentes : Somme, Moyenne,Minimum, Maximum

ServerProcessTerminations Processus serveur arrêtés depuis le dernier rapport.Cela concerne tous les processus serveur qui, pourn'importe quelle raison, ont opéré une transition versl'état TERMINATED, y compris en cas de mise horsservice normale ou anormale du processus.

Unités Count

Statistiques CloudWatch pertinentes : Somme, Moyenne,Minimum, Maximum

Sessions de jeu

Métrique Description :

ActivatingGameSessions Sessions de jeu avec l'état ACTIVATING, ce qui signifiequ'elles sont en cours de démarrage. Les sessions dejeu ne peuvent pas héberger des joueurs tant qu'ellesne sont pas actives. Des chiffres élevés pendant unepériode de temps continue peuvent indiquer que lessessions de jeu ne parviennent pas à passer de l'étatACTIVATING à l'état ACTIVE. Cette métrique peut êtreutilisée avec le dimensionnement automatique.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum

ActiveGameSessions Sessions de jeu avec l'état ACTIVE, ce qui signifiequ'elles sont en mesure d'héberger des joueurs, et

Version205

Amazon GameLift Manuel du développeurMétriques GameLift pour les flottes

Métrique Description :qu'elles hébergent actuellement zéro joueur ou plus.Cette métrique mesure le nombre total de sessions dejeu hébergées actuellement. Cette métrique peut êtreutilisée avec le dimensionnement automatique.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum

AvailableGameSessions Les processus serveur actifs et sains qui ne sont pasactuellement utilisés pour héberger une session dejeu et peuvent démarrer une nouvelle session de jeusans délai pour lancer de nouveaux processus serveurou instances. Cette métrique peut être utilisée avec ledimensionnement automatique.

Note

Pour les flottes qui limitent les activations desession de jeu simultanées, utilisez la métriqueConcurrentActivatableGameSessions.Cette métrique représente plus précisémentle nombre de nouvelles sessions de jeu quipeuvent démarrer sans aucun type de retard.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum

ConcurrentActivatableGameSessions Les processus serveur actifs et sains qui ne sont pasactuellement utilisés pour héberger une session de jeuet qui peuvent immédiatement démarrer une nouvellesession de jeu.

Cette métrique diffère de AvailableGameSessionsde la manière suivante : elle ne compte pas lesprocessus serveur qui ne peuvent actuellement pasactiver une nouvelle session de jeu en raison de limitessur les activations de session de jeu. (Voir la flotteConfiguration de l’exécution paramètre optionnelMaxConcurrentGameSessionActivations).Pour les flottes qui ne limitent pas les activationsde session de jeu, cette métrique est identique àAvailableGameSessions.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum

Version206

Amazon GameLift Manuel du développeurMétriques GameLift pour les files d'attente

Métrique Description :

PercentAvailableGameSessions Pourcentage d'emplacements de session de jeuactifs sur l'ensemble des processus serveur actifs(sains ou non sains) actuellement inutilisés (calculéselon la formule AvailableGameSessions /[ActiveGameSessions +AvailableGameSessions + unhealthy serverprocesses]). Cette métrique peut être utilisée avec ledimensionnement automatique.

Unités Pourcentage

Statistiques CloudWatch pertinentes : Moyenne

GameSessionInterruptions Nombre de sessions de jeu ou d'instances Spot qui ontété interrompues.

Unités Count

Statistiques CloudWatch pertinentes : Somme, Moyenne,Minimum, Maximum

Sessions de joueur

Métrique Description :

CurrentPlayerSessions Sessions de joueur avec soit l'état ACTIVE (le joueurest connecté à une session de jeu active), soit l'étatRESERVED (le joueur s'est vu attribuer un emplacementdans une session de jeu mais ne s'est pas encoreconnecté). Cette métrique peut être utilisée avec ledimensionnement automatique.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum

PlayerSessionActivations Sessions de joueur qui sont passées de l'étatRESERVED à l'état ACTIVE depuis le dernier rapport.Cette situation survient lorsqu'un joueur réussit à seconnecter à une session de jeu active.

Unités Count

Statistiques CloudWatch pertinentes : Somme, Moyenne,Minimum, Maximum

Métriques GameLift pour les files d'attenteL'espace de nom GameLift inclut les métriques suivantes associées à une activité sur une file d'attente deplacement de session de jeu. Les files d'attente sont utilisées avec une solution GameLift gérée. Le serviceGameLift envoie les métriques suivantes à CloudWatch toutes les minutes.

Version207

Amazon GameLift Manuel du développeurMétriques GameLift pour les files d'attente

Métrique Description :

AverageWaitTime Temps d'attente moyen pour satisfaire les demandes deplacement de session de jeu dans la file d'attente avecl'état PENDING.

Unités Seconds

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum, Somme

FirstChoiceNotViable Sessions de jeu correctement placées mais PASdans la flotte de premier choix, car cette dernière aété considérée comme non viable (comme un parcd'instances Spot avec un taux d'interruption élevé). Laflotte de premier choix est la première flotte répertoriéedans la file d'attente ou — quand une requête deplacement inclut les données de latence de la demande— la première flotte choisie par priorisation FleetIQ.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum, Somme

FirstChoiceOutOfCapacity Sessions de jeu correctement placées mais PAS dansla flotte de premier choix, car cette dernière n'avait pasde ressources disponibles. La flotte de premier choix estla première flotte répertoriée dans la file d'attente ou —quand une requête de placement inclut les données delatence de la demande — la première flotte choisie parpriorisation FleetIQ.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum, Somme

LowestLatencyPlacement Sessions de jeu correctement placées dans une régionqui offre la plus faible latence possible de la file d'attentepour les joueurs. Cette métrique est émise uniquementlorsque les données de latence des joueurs sont inclusesdans la requête de placement, ce qui déclenche lapriorisation FleetIQ.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum, Somme

LowestPricePlacement Sessions de jeu qui ont été placées avec succès dansune flotte avec le prix le plus bas possible de la filed’attente pour la région choisie. (FleetIQ définition despriorités choisit d’abord la région avec la latence la plusfaible pour les joueurs, puis trouve la flotte au coût leplus bas dans cette région.) Ce parc peut être un parcd’instances Spot ou une instance à la demande si la filed’attente n’a pas d’instances Spot. Cette métrique est

Version208

Amazon GameLift Manuel du développeurMétriques GameLift pour les files d'attente

Métrique Description :émis uniquement lorsque les données de latence desjoueurs sont incluses dans la requête de placement.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum, Somme

Placement <region name> Sessions de jeu correctement placées dans des flottessitués dans la région spécifiée. Cette métrique décortiquela métrique PlacementsSucceeded par région.

Unités Count

Statistiques CloudWatch pertinentes : Somme

PlacementsCanceled Demandes de placement de session de jeu ayant étéannulées avant expiration depuis le dernier rapport.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum, Somme

PlacementsFailed Requêtes de placement de session de jeu ayant échouépour une quelconque raison depuis le dernier rapport.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum, Somme

PlacementsStarted Nouvelle demandes de placement de session de jeuayant été ajoutées à la file d'attente depuis le dernierrapport.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum, Somme

PlacementsSucceeded Demandes de placement de session de jeu ayant aboutiau lancement d'une nouvelle session de jeu depuis ledernier rapport.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum, Somme

PlacementsTimedOut Demandes de placement de session de jeu ayantatteint la limite d'expiration de la file d'attente sans êtreexécutées depuis le dernier rapport.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum, Somme

Version209

Amazon GameLift Manuel du développeurMétriques GameLift pour l'activité de mise en relation

Métrique Description :

QueueDepth Nombre de demandes de placement de session de jeudans la file d'attente avec l'état PENDING.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum, Somme

Métriques GameLift pour l'activité de mise en relationL'espace de noms GameLift inclut des métriques sur l'activité FlexMatch pour les configurations de miseen relation et les règles de mise en relation. La mise en relation FlexMatch est utilisée avec une solutionGameLift gérée. Le service GameLift envoie les métriques suivantes à CloudWatch toutes les minutes.

Pour plus d'informations sur la séquence de l'activité de mise en relation, consultez Fonctionnementd'Amazon GameLift FlexMatch.

Configurations de mise en relation

Métrique Description :

CurrentTickets Demandes de mise en relation en cours de traitement ouen attente de traitement.

Unités Count

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum, Somme

MatchAcceptancesTimedOut Pour les configurations de mise en relation quinécessitent l'acceptation, les rencontres éventuellesqui ont dépassé le délai lors de l'acceptation depuis ledernier rapport.

Unités Count

Statistiques CloudWatch pertinentes : Somme

MatchesAccepted Pour les configurations de mise en relation quinécessitent l'acceptation, les rencontres éventuelles quiont été acceptées depuis le dernier rapport.

Unités Count

Statistiques CloudWatch pertinentes : Somme

MatchesCreated Mises en relation potentielles ayant été créées depuis ledernier rapport.

Unités Count

Statistiques CloudWatch pertinentes : Somme

MatchesPlaced Mises en relation placées avec succès dans une sessionde jeu depuis le dernier rapport.

Version210

Amazon GameLift Manuel du développeurMétriques GameLift pour l'activité de mise en relation

Métrique Description :Unités Count

Statistiques CloudWatch pertinentes : Somme

MatchesRejected Pour les configurations de mise en relation quinécessitent l'acceptation, les rencontres éventuelles quiont été refusées par au moins un joueur depuis le dernierrapport.

Unités Count

Statistiques CloudWatch pertinentes : Somme

PlayersStarted Joueurs dans des tickets de mise en relation ajoutésdepuis le dernier rapport.

Unités Count

Statistiques CloudWatch pertinentes : Somme

TicketsFailed Demandes de mise en relation ayant entraîné un échecdepuis le dernier rapport.

Unités Count

Statistiques CloudWatch pertinentes : Somme

TicketsStarted Nouvelles demandes de mise en relation ayant étécréées depuis le dernier rapport.

Unités Count

Statistiques CloudWatch pertinentes : Somme

TicketsTimedOut Demandes de mise en relation ayant dépassé le délaidepuis le dernier rapport.

Unités Count

Statistiques CloudWatch pertinentes : Somme

TimeToMatch Pour les demandes de mise en relation qui ont étéplacées dans une mise en relation potentielle avant ledernier rapport, la quantité de temps entre la création duticket et la création de la mise en relation potentielle.

Unités Seconds

Statistiques CloudWatch pertinentes : Échantillons dedonnées, Moyenne, Minimum, Maximum, p99

TimeToTicketCancel Pour les demandes de mise en relation qui ont étéannulées avant le dernier rapport, la quantité de tempsentre la création du ticket et l'annulation.

Unités Seconds

Statistiques CloudWatch pertinentes : Échantillons dedonnées, Moyenne, Minimum, Maximum, p99

Version211

Amazon GameLift Manuel du développeurMétriques GameLift pour un FleetIQ

Métrique Description :

TimeToTicketSuccess Pour les demandes de mise en relation qui ont réussiavant le dernier rapport, la quantité de temps entre lacréation du ticket et le e placement de mise en relationréussi.

Unités Seconds

Statistiques CloudWatch pertinentes : Échantillons dedonnées, Moyenne, Minimum, Maximum, p99

Règles de mise en relation

Métrique Description :

RuleEvaluationsPassed Évaluations des règles pendant le processus de miseen relation qui ont réussi depuis le dernier rapport. Cettemétrique est limitée aux 50 premières règles.

Unités Count

Statistiques CloudWatch pertinentes : Somme

RuleEvaluationsFailed Évaluations des règles pendant l'activité de mise enrelation qui ont échoué depuis le dernier rapport. Cettemétrique est limitée aux 50 premières règles.

Unités Count

Statistiques CloudWatch pertinentes : Somme

Métriques GameLift pour un FleetIQL'espace de noms GameLift inclut des métriques pour le groupe de serveurs de jeu FleetIQ et son activitédans le cadre d'une solution FleetIQ autonome pour l'hébergement de jeux. Le service GameLift envoie lesmétriques suivantes à CloudWatch toutes les minutes. Reportez-vous également à la section Surveillancede vos groupes et instances Auto Scaling à l'aide d'Amazon CloudWatch dans le Amazon EC2 AutoScaling Guide de l'utilisateur.

Pour de plus amples informations sur FleetIQ comme solution autonome, veuillez consulter GameLiftFleetIQGuide (p. 218).

Métrique Description :

AvailableGameServers Serveurs de jeux qui sont disponibles pour exécuter uneexécution de jeu et qui ne sont pas actuellement occupéspar le jeu. Ce nombre inclut les serveurs de jeux qui ontété demandés, mais qui sont toujours à l'état AVAILABLE(DISPONIBLE).

Unités Count

Statistiques CloudWatch pertinentes : Somme

Version212

Amazon GameLift Manuel du développeurMétriques GameLift pour un FleetIQ

Métrique Description :Dimensions : GroupeServeurJeu

UtilizedGameServers Serveurs de jeux qui sont actuellement occupés avec legameplay. Ce nombre inclut les serveurs de jeux dontl'état est UTILIZED (UTILISÉ).

Unités Count

Statistiques CloudWatch pertinentes : Somme

Dimensions : GroupeServeurJeu

DrainingAvailableGameServers Serveurs de jeux sur des instances dont la résiliation estplanifiée et qui ne prennent actuellement pas en chargele gameplay. En cas de nouvelle demande, la priorité dedemande de ces serveurs de jeux est la plus faible.

Unités Count

Statistiques CloudWatch pertinentes : Somme

Dimensions : GroupeServeurJeu

DrainingUtilizedGameServers Serveurs de jeux sur des instances dont la résiliationest planifiée et qui prennent actuellement en charge legameplay.

Unités Count

Statistiques CloudWatch pertinentes : Somme

Dimensions : GroupeServeurJeu

PercentUtilizedGameServers Partie des serveurs de jeux qui prennent actuellementen charge les exécutions de jeux. Cette métrique indiquela capacité du serveur de jeux actuellement utilisé. Elleest utile pour mener une stratégie Auto Scaling qui peutajouter et supprimer dynamiquement des instances afinde correspondre à la demande des joueurs.

Unités Pourcentage

Statistiques CloudWatch pertinentes : Moyenne,Minimum, Maximum

Dimensions : GroupeServeurJeu

GameServerInterruptions Serveurs de jeux sur des instances Spot qui ont étéinterrompus en raison d'une disponibilité limitée desinstances Spot.

Unités Count

Statistiques CloudWatch pertinentes : Somme

Dimensions : GroupeServeurJeu, TypeInstance

Version213

Amazon GameLift Manuel du développeurDimensions pour les métriques GameLift

Métrique Description :

InstanceInterruptions Instances Spot interrompues en raison d'une disponibilitélimitée.

Unités Count

Statistiques CloudWatch pertinentes : Somme

Dimensions : GroupeServeurJeu, TypeInstance

Dimensions pour les métriques GameLiftGameLift prend en charge le filtrage des métriques selon les dimensions suivantes.

Dimension : Description :

FleetId Filtrez les métriques d'une seule flotte. Cette dimensionest utilisée avec toutes les métriques de flotte relativesaux instances, aux processus serveur, aux sessions dejeu et aux sessions de joueur.

MetricGroup Filtrez les métriques pour une collection de flottes.Ajoutez une flotte à un groupe de métriques en ajoutantle nom du groupe de métriques aux attributs de la flotte(voir UpdateFleetAttributes()). Cette dimension estutilisée avec toutes les métriques de flotte relatives auxinstances, aux processus serveur, aux sessions de jeu etaux sessions de joueur.

QueueName Filtrez les métriques pour une seule file d'attente. Cettedimension est utilisée avec les métriques relativesaux files d'attente de placement de session de jeuuniquement.

MatchmakingConfigurationName Filtrez les métriques pour une configuration de mise enrelation unique. Cette dimension est utilisée avec lesmétriques pour les configurations de mise en relation.

MatchmakingConfigurationName-RuleName

Filtrez les métriques pour obtenir l'intersection d'uneconfiguration de mise en relation et d'une règle demise en relation. Cette dimension est utilisée avecles métriques pour les règles de mise en relationuniquement.

InstanceType Filtrez les métriques pour la désignation d'un typed'instance EC2, par exemple « c4.large ». Cettedimension est utilisée avec les métriques pour lesinstances Spot.

OperatingSystem Filtrez les métriques du système d'exploitation d'uneinstance Cette dimension est utilisée avec les métriquesdes instances Spot.

GameServerGroup Filtrer les métriques FleetIQ pour un groupe de serveursde jeu.

Version214

Amazon GameLift Manuel du développeurJournalisation des appels d'API

Journalisation des appels d'API Amazon GameLiftavec AWS CloudTrail

Amazon GameLift est intégré à AWS CloudTrail, un service qui capture tous les appels d'API effectuéspar ou pour Amazon GameLift dans votre compte AWS. CloudTrail vous transmet les fichiers journauxdans un compartiment Amazon S3 que vous spécifiez. CloudTrail capture les appels d'API à partir de laconsole Amazon GameLift ou de l'API Amazon GameLift. Les informations collectées par CloudTrail vouspermettent de déterminer quelle demande a été envoyée à Amazon GameLift, l'adresse IP source à partirde laquelle la demande a été effectuée, qui a effectué la demande, quand, etc. Pour en savoir plus surCloudTrail, y compris la façon de le configurer et de l'activer, consultez le manuel AWS CloudTrail UserGuide.

Informations Amazon GameLift dans CloudTrailLorsque la journalisation CloudTrail est activée dans votre compte AWS, les appels d'API passés auxactions Amazon GameLift sont suivis dans les fichiers journaux. Les enregistrements Amazon GameLiftsont écrits avec d'autres enregistrements de service AWS dans un fichier journal. CloudTrail déterminequand créer un fichier et y consigner des données en fonction d'une période et d'une taille de fichier.

Toutes les actions Amazon GameLift sont enregistrées par CloudTrail. À titre d'exemple, des appels versCreateGameSession, CreatePlayerSession et UpdateGameSession génèrent des entrées dans lesfichiers journaux CloudTrail. Pour obtenir la liste complète des actions, consultez Référence d'API AmazonGameLift.

Chaque entrée du journal contient des informations sur la personne qui a généré la demande. Lesinformations d'identité d'utilisateur figurant dans le journal vous aident à déterminer si la demande a étéeffectuée au moyen d'informations d'identification de compte racine AWS ou d'utilisateur IAM, au moyend'informations d'identification de sécurité temporaires pour un rôle ou un utilisateur fédéré, ou par unautre service AWS. Pour plus d'informations, reportez-vous au champ userIdentity dans le Guide deréférence des événements CloudTrail.

Vous pouvez stocker vos fichiers journaux dans votre compartiment S3 aussi longtemps que vous lesouhaitez, mais vous pouvez également définir des règles de cycle de vie Amazon S3 pour archiver ousupprimer automatiquement les fichiers journaux.

Si vous voulez intervenir rapidement lors de la livraison des fichiers journaux, vous pouvez choisir d'utiliserCloudTrail pour publier des notifications Amazon Simple Notification Service (Amazon SNS) lorsque denouveaux fichiers journaux sont fournis. Pour de plus amples informations, veuillez consulter Configurationdes notifications Amazon SNS.

Vous pouvez également regrouper des fichiers journaux Amazon GameLift provenant de plusieurs régionsAWS et de plusieurs comptes AWS dans un compartiment S3 unique. Pour plus d'informations, consultezla section Regroupement des fichiers journaux CloudTrail dans un compartiment Amazon S3 unique.

Présentation des entrées des fichiers journauxAmazon GameLiftLes fichiers journaux CloudTrail contiennent une ou plusieurs entrées de journal, et chaque entrée estcomposée de plusieurs événements au format JSON. Une entrée de journal représente une demandeindividuelle à partir d'une source quelconque et comprend des informations sur l'action demandée, sur tousles paramètres, sur la date et l'heure de l'action, etc. Les entrées de journal ne sont garanties dans aucunordre particulier. Cela signifie qu'il ne s'agit pas d'une arborescence des appels de procédure ordonnée desappels d'API publics.

Version215

Amazon GameLift Manuel du développeurPrésentation des entrées des

fichiers journaux Amazon GameLift

L'exemple suivant montre une entrée de journal CloudTrail qui illustre les actions CreateFleet etDescribeFleetAttributes.

{ "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", "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": "c5.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": {

Version216

Amazon GameLift Manuel du développeurPrésentation des entrées des

fichiers journaux Amazon GameLift

"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, "requestID": "82e7f0ec-ae85-11e5-a8d6-61d5cafb25f2", "eventID": "11daabcb-0094-49f2-8b3d-3a63c8bad86f", "eventType": "AwsApiCall", "recipientAccountId": "111122223333" }, ]}

Version217

Amazon GameLift Manuel du développeur

GameLift FleetIQGuideGameLift FleetIQ optimise l’utilisation des instances spot à faible coût pour l’hébergement de jeux basésur le cloud avec Amazon EC2. Avec GameLift FleetIQ, vous pouvez travailler directement avec vosressources d’hébergement dans Amazon EC2 et Auto Scaling tout en profitant de GameLift d’optimisationpour offrir un hébergement de jeu peu coûteux et résilient pour vos joueurs. Amazon EC2 Les instancesponctuelles, bien que proposées à des remises abruptes, ne sont généralement pas viables pourl’hébergement de jeux car la disponibilité fluctue et il existe un potentiel pour interruptions. GameLiftFleetIQ atténue de manière significative ces limitations, ce qui permet d’utiliser des instances spot à faiblecoût viables pour l’hébergement de jeux.

FleetIQ d’optimisation sont disponibles avec GameLift solutions d’hébergement de jeux. Si vous préférezune solution d’hébergement de jeux entièrement gérée, consultez la Amazon GameLift Guide dudéveloppeur (p. 1) pour plus d’informations sur d’autres solutions.

Le GameLift FleetIQ La solution d’hébergement de jeux est conçue pour les développeurs de jeux qui :

• Avoir des déploiements AWS existants ou utiliser Amazon EC2 directement plutôt que par le servicede jeu entièrement géré. GameLift FleetIQ fonctionne avec les groupes Auto Scaling que vous gérezsur votre compte AWS, ce qui vous donne accès à votre Amazon EC2 des instances et des groupes.Vous pouvez également intégrer d’autres services AWS, notamment Amazon Elastic Container Service,Amazon Elastic Kubernetes Service, et AWS Shield Advanced.

• disposent d'un hébergement de jeux sur site existant et souhaitent étendre la capacité au cloud. AvecGameLift FleetIQ, vous pouvez construire un système de déploiement hybride qui utilise votre capacitésur site et ajoute de manière incrémentielle la capacité du cloud AWS au besoin.

Prêt à commencer à travailler avec GameLift FleetIQ?

• En savoir plus sur la façon de procéder GameLift FleetIQ travaillez pour vos jeux avec ce Formation en ligne sur la formation et la certification AWS : Utiliser Amazon GameLift FleetIQpour les serveurs de jeux, disponible en anglais et en japonais.

• Suivez cette Démarrez avec GameLift FleetIQ (p. 235) feuille de route.

Rubriques• Comment GameLift FleetIQ travaux (p. 218)• Architecture de jeu avec GameLift FleetIQ (p. 223)• GameLift FleetIQ cycles de vie et états (p. 224)• GameLift FleetIQ configuration (p. 229)• Démarrez avec GameLift FleetIQ (p. 235)• GameLift FleetIQBonnes pratiques (p. 240)• Surveillance d'GameLift FleetIQ avec Amazon CloudWatch (p. 242)• GameLift FleetIQFonctionnalités de (p. 242)

Comment GameLift FleetIQ travauxLe GameLift FleetIQ solution est une couche d’hébergement de jeux qui complète l’ensemble complet desoutils de gestion des ressources informatiques que vous obtenez avec Amazon EC2 et Auto Scaling. En

Version218

Amazon GameLift Manuel du développeurGameLift FleetIQLogique

plus d’offrir une combinaison de caractéristiques spécifiques à l’hébergement de jeux, GameLift FleetIQfournit une couche supplémentaire de logique qui permet d’utiliser des instances ponctuelles à faible coûtpour l’hébergement de jeux. Cette solution vous permet de gérer directement votre Amazon EC2 et AutoScaling ressources et intégration en fonction des besoins avec d’autres services AWS.

Lorsque vous utilisez GameLift FleetIQ, vous préparez à lancer Amazon EC2 comme d’habitude : créezune image Amazon Machine Image (AMI) avec votre logiciel de serveur de jeu, créez Amazon EC2 lemodèle de lancement et définir les paramètres de configuration pour un Auto Scaling groupe. Cependant,au lieu de créer un Auto Scaling directement, vous créez un GameLift FleetIQ groupe de serveurs de jeuxavec votre Amazon EC2 et Auto Scaling ressources et configuration. Cette action invite GameLift FleetIQpour créer un groupe de serveur de jeux et un groupe Auto Scaling groupe. Le groupe de serveurs de jeuxest lié à certains aspects du Auto Scaling groupe.

Après le Auto Scaling est créé, vous avez un accès complet à votre Amazon EC2 et Auto Scalingressources. Vous pouvez modifier la configuration de votre Auto Scaling ajouter, ajouter des politiquesd’évolutivité multiniveaux ou des équilibreurs de charge, et intégrer avec d’autres services AWS. Vouspouvez vous connecter directement aux instances du groupe. Dans le cadre de sa logique d’optimisation,GameLift FleetIQ effectue également des mises à jour périodiques Auto Scaling propriétés du groupe. Vouspouvez suivre le statut de disponibilité de toutes les instances déployées par le Auto Scaling groupe.

Vous pouvez suspendre temporairement GameLift FleetIQ pour un groupe de serveur de jeux à toutmoment. Vous avez également la possibilité de supprimer un groupe de serveur de jeux, mais de conserverle groupe de mise à l’échelle automatique correspondant.

GameLift FleetIQLogiqueLe diagramme suivant illustre le rôle de GameLift FleetIQ lorsqu’il travaille avec Amazon EC2 pourl’hébergement de jeux. Son objectif principal est de localiser meilleur un serveur de jeu possible pourorganiser une session de jeu et donner aux joueurs une expérience de jeu optimale. GameLift FleetIQdéfinit le meilleur des ressources comme celles qui offrent la viabilité d’hébergement de jeux la plus élevéepour le coût le plus bas. GameLift FleetIQ aborde cet objectif de deux manières clés : en premier, enautorisant uniquement les types d’instances viables dans le Auto Scaling groupe, et deuxièmement, enplaçant de nouvelles sessions de jeu efficacement sur les ressources disponibles du groupe.

Version219

Amazon GameLift Manuel du développeurGameLift FleetIQLogique

Remplissage d'un groupe Auto Scaling avec des types d'instanceoptimauxLa tâche du groupe Auto Scaling consiste à lancer de nouvelles instances et à supprimer les anciennesinstances, en maintenant un ensemble de ressources d'hébergement et en le mettant à l'échelle pourrépondre à la demande de vos joueurs. Lorsque vous créez un groupe de serveur de jeux, vous définissezune liste de types d’instances pour Auto Scaling groupe à utiliser. Le travail de GameLift FleetIQ est devérifier en permanence la viabilité de vos types d’instances souhaitées et de mettre à jour cette liste pourle Auto Scaling groupe. Avec ce processus, appelé équilibrage des instances, GameLift FleetIQ s’assureque les nouvelles instances sont lancées uniquement avec des types d’instances viables actuellement, etque les instances existantes sur des types d’instances non viables sont retirées et remplacées. GameLiftFleetIQ affecte la manière dont Auto Scaling Le groupe sélectionne des types d’instances optimaux de lamanière suivante :

• A GameLift FleetIQ groupe de serveurs de jeux est configuré avec une stratégie d’équilibrage, quidétermine si Auto Scaling utilise des instances Spot ou à la demande. Les instances ponctuelles ontdes coûts moindres en raison de la disponibilité et du potentiel fluctuantsinterruptions, les limites quiGameLift FleetIQ minimise l’hébergement du serveur de jeux. Les instances à la demande, bien que pluscoûteuses, offrent une disponibilité plus fiable lorsque vous en avez besoin.

Version220

Amazon GameLift Manuel du développeurGameLift FleetIQLogique

• GameLift FleetIQ Le processus d’équilibrage des instances évalue la viabilité de l’hébergement de jeuxde chaque type d’instance souhaité du groupe de serveurs de jeux. Ce processus utilise un algorithmede prédiction qui évalue la disponibilité récente et le taux d'interruption du type d'instance. Si le risqued’interruption du serveur de jeu est trop élevé, GameLift FleetIQ supprime ce type d’instance non viabledu Auto Scaling la liste des types d’instances souhaitées.

• GameLift FleetIQ identifie les instances existantes du groupe Auto Scaling dont le type d'instance estactuellement considéré comme non viable. Ces instances sont marquées comme vidange, ce qui signifiequ’ils sont terminés et remplacés par de nouvelles instances. La résiliation des instances pour lesquellesla protection du serveur de jeux est activée est reportée jusqu'à ce que les sessions de jeu actives seterminent normalement.

Comme Auto Scaling Le groupe lance et retire des instances, il maintient une collection optimisée pourl’hébergement de jeux, même lorsque la disponibilité des types d’instances spot à faible coût fluctue.L’activité d’équilibrage a lieu sur des groupes de serveurs de jeux avec des instances actives uniquement.En savoir plus sur le fonctionnement de ce processus dans Processus d’équilibrage des points (p. 224).

Placement efficace des sessions de jeuxGameLift FleetIQ assure le suivi de tous les serveurs de jeux actifs dans le groupe de serveurs de jeuxet utilise ces informations pour déterminer le meilleur placement pour les nouvelles sessions de jeu et lesnouveaux joueurs.

Pour permettre à GameLift FleetIQ d'assurer le suivi des serveurs de jeu, votre logiciel de serveur de jeuxdoit signaler son état. Votre AMI personnalisée contrôle la façon dont les nouveaux processus de serveurde jeux sont démarrés et arrêtés sur chaque instance. Lorsqu'un nouveau serveur de jeux est démarré,il s'enregistre auprès de GameLift FleetIQ, indiquant qu'il est prêt à héberger une session de jeux. Aprèsl'enregistrement, le serveur de jeux signale régulièrement son état et indique s'il héberge actuellementune session de jeu. Lorsque le serveur de jeux s'arrête, il annule son enregistrement auprès de GameLiftFleetIQ.

Pour démarrer une nouvelle session de jeu, votre client de jeu (ou un matchmaker ou autre service client)envoie une demande pour un serveur de jeu à GameLift FleetIQ. GameLift FleetIQ localise un serveur dejeu disponible, le demande pour la nouvelle session de jeu et répond avec l’ID du serveur de jeu et les infosde connexion. Votre jeu invite ensuite le serveur de jeux à mettre à jour son état et à démarrer une nouvellesession de jeu pour les joueurs entrants.

Lors de la sélection d'un serveur de jeux pour héberger une nouvelle session de jeu, GameLift FleetIQutilise le processus de prise de décision suivant pour optimiser le placement avec des instances Spotviables à faible coût :

1. Dans la mesure du possible, GameLift FleetIQ place de nouvelles sessions de jeu sur des instances quihébergent déjà d'autres sessions de jeu. En empaquetant (sans surcharger) certaines instances et engardant d'autres instances inactives, le groupe Auto Scaling est en mesure de diminuer rapidement lesinstances inactives lorsqu'elles ne sont pas nécessaires, ce qui réduit les coûts d'hébergement.

2. GameLift FleetIQ ignore les instances marquées comme vidange, qui n’est pas viable pourl’hébergement de jeux. L'exécution de ces instances est maintenu uniquement pour prendre en chargeles sessions de jeu existantes. Elles ne peuvent pas être utilisées pour de nouvelles sessions de jeu,sauf si aucun autre serveur de jeux n'est disponible.

3. GameLift FleetIQ identifie tous les serveurs de jeux disponibles qui s'exécutent sur des instancesviables.

Vous pouvez activer la protection des sessions de jeu pour un groupe de serveurs de jeux afin d'empêcherque le groupe Auto Scaling résilie des instances comportant des sessions de jeu actives.

Version221

Amazon GameLift Manuel du développeurRessources et composants clés

Ressources et composants clésCréez les ressources suivantes dans votre compte AWS avant de configurer vos ressourcesd'hébergement de jeux avec GameLift FleetIQ. À titre de bonne pratique, développez et testez votredéploiement de serveur de jeux avec ces ressources avant de les utiliser avec un groupe de serveurs dejeux.

• Amazon Machine Image (AMI) Un AMI est un modèle pour une configuration logicielle spécifique quevous souhaitez lancer avec votre Amazon EC2 instances. Pour l'hébergement de jeux, votre AMI inclutun système d'exploitation, les binaires ou un conteneur de votre serveur de jeux et d'autres logicielsd'exécution dont votre serveur de jeux a besoin. Pour plus d’informations sur la création d’un AMI,consultez Images de machine Amazon dans le Amazon EC2 Guide de l'utilisateur pour les instancesLinux. Les AMI sont spécifiques à une région. Vous pouvez copier un AMI d’une région à l’autre, commedécrit dans Copie des amis dans le Guide d’utilisation Amazon EC2.

• Amazon EC2 launch-template Un modèle de lancement fournit des instructions pour lancer et gérerles instances dans un Auto Scaling groupe. Il spécifie une AMI, fournit une liste de types d'instanceappropriés et définit le réseau, la sécurité ainsi que d'autres propriétés. Pour plus d’informations sur lacréation d’un modèle de lancement, voir Lancement d’une instance à partir d’un modèle de lancement dans le Guide d’utilisation Amazon EC2. Les modèles de lancement sont spécifiques à une région.

• Rôle IAM AWS. Un rôle IAM définit un ensemble d'autorisations qui permettent un accès limité auxressources AWS. Une entité de confiance, par exemple un autre service AWS, peut assumer le rôleet hériter de ses autorisations. Lorsque vous utilisez GameLift FleetIQ, vous devez fournir un rôle IAMavec une politique gérée qui permet GameLift FleetIQ pour créer et accéder aux groupes d’évolutivitéautomatique et aux ressources d’instance EC2 de votre compte AWS. Les rôles IAM ne sont passpécifiques à une région.

GameLift FleetIQ gère directement les ressources suivantes et exerce une autorité directe sur celles-ci.

• Groupe de serveurs de jeux GameLift. Un groupe de serveurs de jeux contient des paramètres deconfiguration qui définissent la manière dont GameLift FleetIQ fonctionne avec un Auto Scaling pour offrirun hébergement de jeux à bas coût. Les groupes de serveurs de jeux sont spécifiques à une région.Lorsque vous créez un groupe de serveurs de jeux dans une région, un nouveau groupe Auto Scalingest automatiquement créé dans votre compte AWS dans la même région. Le groupe de serveurs de jeuxest lié au groupe Auto Scaling et dispose d'un accès (en assumant le rôle IAM) pour gérer et modifiercertains de ses paramètres. Un groupe de serveurs de jeux est une ressource de longue durée ; il estrare que les développeurs doivent en créer. Un groupe de serveurs de jeux est également une ressourcede regroupement fonctionnelle pour les serveurs de jeux hébergés sur des instances du groupe AutoScaling et enregistrés auprès de GameLift FleetIQ.

• Serveur de jeux GameLift. Une ressource de serveur de jeux représente une exécution de jeu quifonctionne sur une instance associée à un GameLift FleetIQ groupe de serveurs de jeux. Cette ressourceest créée lorsqu’un serveur de jeux enregistre GameLift FleetIQ et identifie le groupe de serveur de jeuxauquel il appartient. GameLift FleetIQ suit l’état d’utilisation et l’état de la demande de chaque serveur dejeu enregistré, ce qui lui permet de surveiller la disponibilité du serveur de jeux. Les serveurs de jeux sontspécifiques à une région en ce sens qu'ils sont associés à un groupe de serveurs de jeux spécifique àune région. Lorsque votre jeu demande un nouveau serveur de jeux, il spécifie le groupe de serveurs dejeux et la région.

Ces ressources sont créées via GameLift FleetIQ ressources. Elles sont créées dans votre compte AWS etvous exercez un contrôle total sur ces ressources.

• Amazon EC2 Groupe Auto Scaling Un groupe Auto Scaling lance et gère un ensemble d'instances EC2et met automatiquement à l'échelle la capacité du groupe. Avec GameLift FleetIQ, il existe une relationindividuelle entre le groupe de serveurs de jeux et le groupe Auto Scaling. Bien que vous puissiezmettre à jour tous les paramètres d'un groupe Auto Scaling, GameLift FleetIQ remplace et met à jourrégulièrement certains paramètres dans le cadre de sa logique d'équilibrage des instances Spot pour

Version222

Amazon GameLift Manuel du développeurArchitecture de jeu

assurer la viabilité de l'hébergement de jeux. Pour plus d’informations, voir groupe autoscalinggroupdans le Amazon EC2 Auto Scaling Guide de l'utilisateur. Les groupes Auto Scaling sont spécifiques àune région ; ils sont créés dans la même région que le groupe de serveurs de jeux.

• Amazon EC2 Instance Une instance est un serveur virtuel dans le cloud . Les types d'instance ontdes configurations matérielles spécifiques qui spécifient les ressources de calcul, de mémoire, dedisque et de réseau. Ils sont généralement lancés par un groupe Auto Scaling avec une AMI. Lesinstances peuvent être Spot ou à la demande, selon la disponibilité. Avec GameLift FleetIQ, les instancesexécutent un ou plusieurs processus de serveur de jeux, chacun pouvant héberger plusieurs sessionsde jeu. Les instances sont spécifiques à une région en ce sens qu'elles sont associées à un groupe AutoScaling spécifique à une région.

Architecture de jeu avec GameLift FleetIQSupplément d’hébergement sur siteGameLift FleetIQ est conçu pour réutiliser votre backend de jeu existant, notamment les routages IPgéographiques des joueurs, la mise en relation ou les services de lobby déjà en place. L'exemple suivantillustre comment GameLift FleetIQ peut s'intégrer dans un déploiement sur site existant.

Example

Dans cet exemple, l'hébergement de jeux est initialement géré avec quatre centres de donnéespropriétaires pour héberger les joueurs en Amérique du Nord et en Europe. En fonction de leuremplacement physique approximatif, les joueurs sont dirigés vers l'un des deux matchmakers régionaux.Les matchmakers regroupent les joueurs par compétence et latence, puis les placent sur les serveurs dejeux à proximité afin de minimiser le décalage.

Le développeur de jeu souhaite remplacer les serveurs de jeux situés en Amérique du Nord par desserveurs fournis par GameLift FleetIQ. Pour commencer, il apporte des mises à jour mineures au serveurde jeux afin qu'il puisse être utilisé avec GameLift FleetIQ, puis il crée une Amazon machine image (AMI).Cette image sera installée sur chaque instance EC2 déployée pour le jeu. L'image contient le serveurde jeux, les dépendances et tous les éléments nécessaires pour exécuter des sessions de jeu pour lesjoueurs.

Version223

Amazon GameLift Manuel du développeurCycles de vie et états

Avec l’AMI prêt, le développeur crée deux GameLift FleetIQ groupes de serveurs de jeux, un pour chaquerégion AWS Amérique du Nord (us-east-1 et us-west-2). Le développeur passe dans le modèle delancement (qui fournit l’AMI), la liste des types d’instance souhaités et d’autres paramètres de configurationpour le groupe. La liste des types d’instances souhaitées indique GameLift FleetIQ quels types à utiliserlors de la vérification des instances ponctuelles qui sont viables pour l’hébergement de jeux.

Enfin, le développeur intègre le SDK AWS avec GameLift FleetIQ dans leur matchmaker nord-américain,qui appelle GameLift FleetIQ lorsqu’un nouveau groupe de joueurs a besoin de la capacité serveur pourune session de jeu. GameLift FleetIQ localise une instance spot avec un serveur de jeu disponible, leréserve pour les joueurs et fournit des informations de connexion au serveur. Les joueurs se connectent auserveur, jouent au jeu et se déconnectent. Pour démarrer un nouveau jeu, les joueurs entrent à nouveaudans le matchmaking, ce qui indique à GameLift FleetIQ de trouver un autre serveur de jeux disponible. Àchaque nouvelle demande de jeu, GameLift FleetIQ doit rechercher et sélectionner des serveurs de jeuxayant peu de chances d'être interrompus. Ainsi, GameLift FleetIQ éloigne en permanence les joueurs desserveurs de jeux qui ne sont pas viables pour l'hébergement de jeux, même lorsque la disponibilité desinstances Spot fluctue au fil du temps.

GameLift FleetIQ cycles de vie et étatsProcessus d’équilibrage des pointsGameLift FleetIQ équilibre périodiquement les instances dans unAuto Scaling avec des instancesponctuelles. Ce processus n’est pas actif avec les groupes de serveurs de jeux qui utilisent la stratégied’équilibrage ON_DEMAND_ONLY ou n’ont pas de instances actives.

L’équilibrage des points a deux objectifs clés :

• Pour actualiser constamment le groupe en utilisant uniquement des types d’instances de points viablespour l’hébergement de jeux.

• Utiliser plusieurs types d'instance viables (si possible) afin de réduire l'impact des interruptionsinattendues du serveur de jeux.

GameLift FleetIQ les soldes en évaluant les types d’instances du groupe et en supprimant les instancesqui sont plus susceptibles d’entraîner des interruptions de serveur de jeu. Pour éviter de mettre fin à desinstances avec jeu actif pendant l’équilibrage, la meilleure pratique consiste à activer la protection desserveurs de jeux pour un groupe de serveurs de jeux en production.

Version224

Amazon GameLift Manuel du développeurProcessus d’équilibrage des points

Example

L’exemple suivant illustre comment les instances d’un groupe de mise à l’échelle automatique sontaffectées par équilibrage des points.

• Étape 1. Par le biais d'un groupe de serveurs de jeux, le groupe Auto Scaling lié est configuré pourlancer des instances de types m4.large, c4.large et c5.large avec protection du serveur de jeux activée.Le groupe Auto Scaling a lancé un ensemble équilibré composé de deux instances Spot de chaque type.Quatre instances ont au moins un serveur de jeux à l'état UTILIZED (UTILISÉ) (entouré de pointillés),tandis que deux instances ne prennent pas en charge le jeu actuellement.

• Étape 2. GameLift FleetIQ évalue la viabilité actuelle de l’hébergement des jeux des trois typesd’instances. L’évaluation détermine que le type d’instance c4.grand a un potentiel inacceptable pourl’interruption du serveur de jeu. GameLift FleetIQ met immédiatement à jour le Auto Scaling configurationde groupe pour supprimer provisoirement c4.grand de la liste des types d’instance, empêchant ainsi lesinstances c4 supplémentaires d’être lancées.

• Étape 3. GameLift FleetIQ identifie les instances existantes du type c4.grand et prend des mesurespour les supprimer du groupe. Pour la première étape, tous les serveurs de jeux fonctionnant sur c4.degrandes instances sont marqués comme vidange. Les serveurs de jeux sur des instances de drainage nepeuvent être demandés qu'en dernier recours, si aucun autre serveur de jeux n'est disponible. En outre,un groupe Auto Scaling comportant des instances à l'état « drainage » est déclenché afin de lancer denouvelles instances pour les remplacer.

• Étape 4. Au fur et à mesure que de nouvelles instances viables sont en ligne, le groupe Auto Scalingrésilie les instances à l'état « drainage ». Ce remplacement garantit le maintien de la capacité souhaitéedu groupe. La première instance résiliée est l'instance c4.large qui ne comporte pas de serveurs dejeux utilisés et dont la protection du serveur de jeux est désactivée. Elle est remplacée par une nouvelleinstance c5.large.

• Étape 5 : Les instances à l'état « drainage » avec protection du serveur de jeux continuent à s'exécuterpendant que leurs serveurs de jeux prennent en charge le gameplay. Lorsque le gameplay est terminé,l'instance c4.large restante est résiliée quand une nouvelle instance m4.large a été lancée pour laremplacer.

À la suite de ce processus, le groupe Auto Scaling conserve sa capacité souhaitée tandis que les soldes degroupe d’utilisation de trois types d’instances à deux. GameLift FleetIQ continue d’évaluer la liste originale

Version225

Amazon GameLift Manuel du développeurDurée de vie d’un groupe de serveurs de jeux

des types d’instances pour la viabilité d’hébergement des jeux. Lorsque c4.large est à nouveau considérécomme un type d'instance viable, le groupe Auto Scaling est mis à jour de manière à inclure les trois typesd'instance. Le groupe équilibre naturellement le temps.

Durée de vie d’un groupe de serveurs de jeuxLes groupes de serveurs de jeux passent par le cycle de vie suivant, qui inclut la mise en service et lesmises à jour de l'état. Un groupe de serveurs de jeux est censé être une ressource de longue durée

• Vous créez un groupe de serveurs de jeux en appelant le GameLift API CreateGameServerGroup()et le passage dans un modèle de lancement EC2 et des paramètres de configuration. En réponse àl'appel, un nouveau groupe de serveurs de jeux est créé et placé à l'état NEW (NOUVEAU).

• GameLift FleetIQ active un flux de travail d'activation asynchrone, ce qui fait passer l'état du groupe deserveurs de jeux à ACTIVATING (ACTIVATION). Le flux de travail initie la création de ressources sous-jacentes, y compris un groupe Amazon EC2 Auto Scaling et une instance EC2 avec l'AMI fournie.• Si la mise en service échoue, quelle que soit la raison, le groupe de serveurs de jeux est placé à

l'état ERROR (ERREUR). Pour obtenir des informations supplémentaires sur les erreurs pour aider àdéboguer la cause de l'échec, appelez DescribeGameServerGroup() sur un groupe de serveursde jeux dont l'état est ERROR (ERREUR).

• Si la mise en service réussit, le groupe de serveurs de jeux passe à l'état ACTIVE (ACTIF). À ce stade,les instances sont lancées avec des serveurs de jeux enregistrés auprès de GameLift FleetIQ. Lestypes d’instances du groupe sont régulièrement évalués pour la viabilité de l’hébergement des jeux etéquilibrés selon les besoins. GameLift FleetIQ suit également l’état des serveurs de jeux actifs dans legroupe et répond aux demandes de serveurs de jeux.

• Pour supprimer un groupe de serveurs de jeux, vous appelez DeleteGameServerGroup()avec l'identificateur de groupe. Cette action place le groupe de serveurs de jeux à l'étatDELETE_SCHEDULED (SUPPRESSION_PLANIFIÉE). Seuls les groupes de serveurs de jeux à l'étatACTIVE (ACTIF) ou ERROR (ERREUR) peuvent être planifiés afin d'être supprimés.

• GameLift FleetIQ active un flux de travail de désactivation asynchrone en réponse à l'étatDELETE_SCHEDULED (SUPPRESSION_PLANIFIÉE), en faisant passer l'état du groupe de serveursde jeux à DELETING (SUPPRESSION). Vous avez la possibilité de supprimer uniquement le groupe deserveurs de jeux ou de supprimer à la fois le groupe de serveurs de jeux et le groupe Auto Scaling lié.• Si la désactivation échoue, quelle qu'en soit la raison, l'état du groupe de serveurs de jeux devient

ERROR (ERREUR). Pour obtenir des informations supplémentaires sur les erreurs pour aider àdéboguer la cause de l'échec, appelez DescribeGameServerGroup() sur un groupe de serveursde jeux dont l'état est ERROR (ERREUR).

• Si la désactivation réussit, le groupe de serveurs de jeux passe à l'état DELETED (SUPPRIMÉ).

Version226

Amazon GameLift Manuel du développeurDurée de vie d’un serveur de jeux

Durée de vie d’un serveur de jeuxAvec GameLift FleetIQ, les serveurs de jeux passent par le cycle de vie suivant, qui inclut la mise enservice et les mises à jour de l'état. Un serveur de jeux est censé être une ressource de courte durée. Entant que meilleure pratique, les serveurs de jeu doivent être déenregistrés après la fin d’une session dejeu plutôt que d’être réutilisés pour une autre session de jeu. Cette approche permet de garantir que lesserveurs de jeu disponibles fonctionnent toujours sur les ressources les plus économiques qui sont viablespour l’hébergement de jeux.

• Une ressource de serveur de jeu est créée lorsque le processus du serveur de jeux s’exécutesur une instance dans un GameLift FleetIQ-lié Auto Scaling groupe, appelle GameLift APIRegisterGameServer() à notifier GameLift FleetIQ qu’il est prêt à accueillir les joueurs et gameplay.Un serveur de jeux dispose de deux états pour assurer le suivi de la disponibilité actuelle :• L'état d'utilisation indique si le serveur de jeux prend actuellement en charge le gameplay. Cet état est

initialement défini sur AVAILABLE (DISPONIBLE), ce qui indique que le serveur est prêt à accepter unnouveau gameplay. Une fois que le serveur de jeux est occupé par le gameplay, cet état est défini surUTILIZED (UTILISÉ).

• L'état de la demande indique si le serveur de jeux est demandé pour un gameplay imminent. L'étatCLAIMED (DEMANDÉ) indique qu'un serveur de jeux a été temporairement réservé par un client dejeu (ou un service de jeu tel qu'un matchmaker). Cet état empêche GameLift FleetIQ de fournir lemême serveur de jeux à plusieurs demandeurs. Un serveur de jeux dont l'état de demande est videpeut être demandé.

• Le diagramme suivant illustre comment l'état d'utilisation et l'état de demande d'un serveur de jeuxévoluent au cours de la durée de vie du serveur.

Version227

Amazon GameLift Manuel du développeurDurée de vie d’un serveur de jeux

• Étape 1. Un groupe de serveurs de jeux dispose de six serveurs de jeux enregistrés. L'état d'utilisationde quatre serveurs de jeux est AVAILABLE (DISPONIBLE) (A, B, C et D) et l'état d'utilisation des deuxautres est actuellement UTILIZED (UTILISÉ) (E et F).

• Étape 2. Un client de jeu ou un système de matchmaking appelle GameLift APIClaimGameServer() pour demander un nouveau serveur de jeu. Cette demande invite GameLiftFleetIQ pour rechercher un serveur de jeu disponible (D) et régler son statut de réclamation surRÉCLAMÉ pendant 60 secondes. GameLift FleetIQ répond à sa demande avec les informations deconnexion pour le serveur de jeu (adresse IP et port), ainsi que d’autres données spécifiques au jeuen option. Comme le gameplay n'a pas encore commencé sur le serveur de jeux, l'état d'utilisation duserveur reste AVAILABLE (DISPONIBLE), mais il ne peut pas être demandé par le biais d'une autredemande.

• Étape 3a. À l'aide des informations de connexion fournies, les clients de jeu peuvent se connecter auserveur de jeux et lancer le gameplay. Le serveur de jeux (D) doit être déclenché dans un délai de60 secondes pour que son état d'utilisation passe à UTILIZED (UTILISÉ) lors de l'appel de GameLiftde l'API UpdateGameServer().

• Étape 3b. Si l'état d'utilisation du serveur de jeux n'est pas mis à jour dans les 60 secondes, leminuteur de demande expire et l'état de la demande est à nouveau vide. Le serveur de jeux (D) estrenvoyé dans le pool des serveurs de jeux disponibles et non demandés.

• Une ressource de serveur de jeux est supprimée lorsque le gameplay sur le serveur de jeux est terminéet que les joueurs se sont déconnectés. Avant de s’arrêter, le processus du serveur de jeux appelleGameLift API DeregisterGameServer() à notifier GameLift FleetIQ de son départ du groupe deserveurs de jeux de serveurs de jeux.

Version228

Amazon GameLift Manuel du développeurConfiguration

GameLift FleetIQ configurationLes rubriques de cette section aident à définir les tâches, y compris la manière de configurer votre AWScompte à utiliser avec Amazon GameLift FleetIQ.

Rubriques• Logiciels pris en charge par GameLift FleetIQ (p. 229)• Configurez votre compte AWS pour GameLift FleetIQ (p. 229)

Logiciels pris en charge par GameLift FleetIQGameLift FleetIQ est utilisé pour déployer des serveurs de jeux multijoueur 64 bits, des clients etdes services de jeux pour un hébergement sur Amazon EC2. Cette solution prend en charge lesenvironnements suivants :

Systèmes d'exploitation pour serveurs de jeux

Vous pouvez utiliser GameLift FleetIQ avec les serveurs de jeux qui s'exécutent sur l'un des systèmesd'exploitation pris en charge par EC2. Cela inclut Amazon Linux, Ubuntu, Windows Server, Red HatEnterprise Linux, SUSE Linux Enterprise Server, Fedora, Debian, CentOS, Gentoo Linux, Oracle Linux,et FreeBSD. Consultez les fonctionnalités EC2 actuelles et la prise en charge des fonctionnalités AmazonEC2.

Utilisation de conteneurs

Si votre serveur de jeux utilise des conteneurs, GameLift FleetIQ prend en charge l'intégration avecKubernetes Amazon Elastic Container Service (Amazon ECS) et Amazon Elastic Kubernetes Service(EKS). Voir plus d'informations sur les Conteneurs sur AWS.

Environnements de développement de jeux

Les clients et serveurs de jeux nécessitent une certaine intégration pour communiquer avec le serviceGameLift FleetIQ. Les jeux réalisent des appels d’API vers le kit SDK AWS. Téléchargez le kit AWS SDKou consultez la documentation de référence des API Amazon GameLift.

Le kit AWS SDK avec Amazon GameLift est disponible dans les langages suivants. Consultez ladocumentation pour chaque langage et en savoir plus sur la prise en charge des environnements dedéveloppement.

• C++ (Docs SDK) (Amazon GameLift)• Java (Docs SDK) (Amazon GameLift)• .NET (Docs SDK) (Amazon GameLift)• Go (Docs SDK) (Amazon GameLift)• Python (Docs SDK) (Amazon GameLift)• Ruby (Docs SDK) (Amazon GameLift)• PHP (Docs SDK) (Amazon GameLift)• JavaScript/Node.js ((Docs SDK) (Amazon GameLift)

Configurez votre compte AWS pour GameLift FleetIQUtiliser GameLift FleetIQ avec Amazon EC2, Auto Scaling, et autres AWS vous devez définir lesautorisations d’accès pour ces services AWS. Les autorisations de compte AWS sont gérées avec AWSIdentity and Access Management (IAM). Réalisez les tâches suivantes :

Version229

Amazon GameLift Manuel du développeurConfigurez votre compte AWS

• Si vous n'avez pas encore de compte AWS, créez-en un maintenant avec GameLift FleetIQ.• Définissez des autorisations spécifiques à GameLift FleetIQ pour les utilisateurs et les groupes

d'utilisateurs. Veuillez consulter Mettre à jour les autorisations utilisateur IAM (p. 230).• Créer IAM rôles pour permettre GameLift et votre Amazon EC2 ressources pour interagir. Veuillez

consulter Créer des rôles IAM pour l'interaction entre services (p. 231).

Mettre à jour les autorisations utilisateur IAMUtilisateurs qui travaillent avec GameLift FleetIQ groupes de serveurs de jeux et Amazon EC2 et AutoScaling Les services doivent avoir des autorisations pour accéder à ces services. Vous pouvez définir desautorisations pour des utilisateurs individuels ou des groupes d'utilisateurs et limiter l'accès des utilisateurspar service, action ou ressource.

1. Ouvert Amazon Web Services et choisissez Connectez-vous à la console. Suivez les invites afin decréer un nouveau compte ou de vous connecter à un compte existant.

2. Ouvrir le Console IAM et, si nécessaire, définissez les utilisateurs ou groupes d’utilisateurs pour voséquipes de jeux. Pour des instructions détaillées, voir Création des utilisateurs IAM. Vous pouvezégalement gérer des utilisateurs et des groupes d'utilisateurs avec l'interface de ligne de commandeAWS.

3. Pour chaque utilisateur ou groupe d’utilisateurs pour vos équipes de jeu, joignez une politiqued’autorisations avec les autorisations requises pour GameLift FleetIQ, comme indiqué dans la politiquesuivante. Les utilisateurs et les groupes d'utilisateurs peuvent avoir plusieurs stratégies d'autorisations,selon les besoins.

Pour attacher la stratégie, ouvrez la page récapitulative de l'utilisateur ou du groupe d'utilisateurs etrecherchez l'option permettant de créer une stratégie en ligne (personnalisée). Copiez la syntaxeJSON ci-dessous. Si vous utilisez AWS CloudFormationpour gérer vos ressources d’hébergement dejeux, ajoutez AWS CloudFormation autorisations à la syntaxe de la politique. Enregistrez la nouvellepolitique.

GameLift FleetIQ_policy

{ "Version": "2012-10-17", "Statement": [ { "Action": [ "iam:PassRole" ], "Effect": "Allow", "Resource": "*" }, { "Action": [ "iam:CreateServiceLinkedRole" ], "Effect": "Allow", "Resource": "arn:*:iam::*:role/aws-service-role/autoscaling.amazonaws.com/AWSServiceRoleForAutoScaling" }, { "Action": [ "autoscaling:CreateAutoScalingGroup", "autoscaling:DescribeAutoScalingGroups", "autoscaling:ExitStandby", "autoscaling:PutLifecycleHook", "autoscaling:PutScalingPolicy", "autoscaling:ResumeProcesses", "autoscaling:SetInstanceProtection",

Version230

Amazon GameLift Manuel du développeurConfigurez votre compte AWS

"autoscaling:UpdateAutoScalingGroup", "autoscaling:DeleteAutoScalingGroup" ], "Effect": "Allow", "Resource": "*" }, { "Action": [ "ec2:DescribeAvailabilityZones", "ec2:DescribeSubnets", "ec2:RunInstances" ], "Effect": "Allow", "Resource": "*" }, { "Action": [ "events:PutRule", "events:PutTargets" ], "Effect": "Allow", "Resource": "*" } ]}

Autorisations supplémentaires pour AWS CloudFormation

{ "Action": [ "autoscaling:CreateOrUpdateTags", "autoscaling:DescribeLifecycleHooks", "autoscaling:DescribeNotificationConfigurations", "ec2:DescribeLaunchTemplateVersions" ] "Effect": "Allow", "Resource": "*" }

Créer des rôles IAM pour l'interaction entre servicesPour GameLift FleetIQ de travailler avec votre Amazon EC2 et Auto Scaling vous devez autoriser lesservices à interagir entre eux. Pour ce faire, il faut créer des rôles IAM dans votre compte AWS. Chaquerôle identifie les services qui peuvent assumer le rôle et un ensemble d’autorisations limitées.

Configurez les rôles suivants :

• Création d'un rôle pour GameLift FleetIQ (p. 231) pour mettre à jour votre Amazon EC2 ressources.• Création d'un rôle pour Amazon EC2 (p. 233) ressources pour communiquer avec GameLift FleetIQ.

Création d'un rôle pour GameLift FleetIQ

Ce rôle permet GameLift FleetIQ pour accéder à votre Amazon EC2 instances, Auto Scaling et crochets decycle de vie dans le cadre de son équilibrage des points et des activités d’échelonnage automatique.

Utilisez la console IAM ou l'interface de ligne de commande AWS pour créer un rôle GameLift FleetIQ etattacher une stratégie gérée avec les autorisations nécessaires. Pour plus d’informations sur IAM rôles etpolitiques gérées, voir Créer un rôle pour un service AWS et Politiques gérées par AWS.

Version231

Amazon GameLift Manuel du développeurConfigurez votre compte AWS

Console

Ces étapes décrivent comment créer un rôle de service avec une stratégie gérée pour GameLift àl’aide de la AWS Management Console.

1. Ouvrir le Console IAM et choisissez Rôles : Création d'un rôle .2. Pour Sélectionner le type d’entité approuvée, choisissez Service AWS.3. Pour Choisir un cas d’utilisation, choisissez gamelift de la liste des services. Sous Sélectionnez

votre cas d’utilisation, le bon GameLift le cas d’utilisation est automatiquement sélectionné. Pourcontinuer, choisissez Suivant : Permissions.

4. La liste Politiques d’autorisations jointes doit contenir une politique :gameliftgameservergrouppolicy . Si cette stratégie n'est pas affichée, vérifiez les filtres ou utilisezla fonction de recherche pour l'ajouter au rôle. Vous pouvez afficher la syntaxe d'une stratégie(choisissez l'icône ▶ à développer), mais vous ne pouvez pas modifier la syntaxe. Lorsque le rôleest créé, vous pouvez mettre à jour le rôle et joindre des politiques supplémentaires pour ajouterou supprimer des autorisations.

Pour Définir la limite des autorisations, conserver le paramètre par défaut (Créer un rôle sanslimite d’autorisations). Il s'agit d'un paramètre avancé qui n'est pas requis. Pour continuer,choisissez Suivant : Tags (Balises) .

5. Ajouter des balises est un paramètre facultatif pour la gestion des ressources. Par exemple, vouspouvez ajouter des balises à ce rôle pour suivre l’utilisation des ressources spécifiques au projetpar rôle. Pour voir plus d’informations sur l’étiquetage pour IAM rôles et autres utilisations, suivezles En savoir plus. Pour continuer, choisissez Suivant : Vérifiez .

6. Sur le Examen page, effectuez les modifications suivantes si nécessaire :

• Saisissez un nom de rôle et, éventuellement, mettez à jour la description.• Vérifiez les paramètres suivants :

• Entités fiables est défini sur « AWS service : gamelift.amazonaws.com ». Cette valeur doitêtre mise à jour une fois le rôle créé.

• Politiques comprend gameliftgameservergrouppolicy.

Pour terminer la tâche, choisissez Créer un rôle.7. Une fois le nouveau rôle créé, vous devez mettre à jour manuellement la relation de confiance du

rôle. Aller au Rôles et choisissez le nouveau nom de rôle pour ouvrir sa page récapitulative. Ouvrirle Relations de confiance et choisissez Modifier la relation de confiance. Dans le document depolitique, mettez à jour Service propriété à inclure autoscaling.amazonaws.com. La révisionService les biens doivent ressembler à ceci :

"Service": [ "gamelift.amazonaws.com", "autoscaling.amazonaws.com" ]

Pour enregistrer votre modification, choisissez Mettre à jour la politique de fiducie.

Le rôle est maintenant prêt. Notez la valeur de l’ARN du rôle, qui s'affiche en haut de la page derésumé de ce dernier. Vous aurez besoin de ces informations lors de la configuration GameLift FleetIQgroupes de serveurs de jeux.

AWS CLI

Ces étapes décrivent comment créer un rôle de service avec une stratégie gérée pour GameLift àl'aide de l'interface de ligne de commande AWS.

Version232

Amazon GameLift Manuel du développeurConfigurez votre compte AWS

1. Créez un fichier de stratégie d'approbation (exemple : FleetIQtrustpolicyGameLift.json)avec la syntaxe JSON suivante :

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

2. Créer un nouveau IAM rôle avec iam créer rôle et associez-le au fichier JSON de la politique trustque vous venez de créer.

Windows:

aws iam create-role --role-name FleetIQ-role-for-GameLift --assume-role-policy-document file://C:\policies\FleetIQtrustpolicyGameLift.json

Linux*

aws iam create-role --role-name FleetIQ-role-for-GameLift --assume-role-policy-document file://policies/FleetIQtrustpolicyGameLift.json

Lorsque la demande est réussie, la réponse inclut les propriétés du rôle nouvellement créé. Notezla valeur de l'ARN. Vous aurez besoin de ces informations lors de la configuration GameLiftFleetIQ groupes de serveurs de jeux.

3. Utiliser politique-de-rôle-attach-iam pour joindre la politique d’autorisations gérées «gameliftgameservergrouppolicy ».

aws iam attach-role-policy --role-name FleetIQ-role-for-GameLift --policy-arn arn:aws:iam::aws:policy/GameLiftGameServerGroupPolicy

Pour vérifier que la politique d’autorisations est jointe, appelez le politiques-rôles-ci-joint-iam avecle nom du nouveau rôle.

Le rôle est maintenant prêt. Vous pouvez vérifier que le rôle IAM est configuré correctement enappelant gamelift create-game-server-group avec le role-arn propriété définie sur la valeur ARN dunouveau rôle. Lorsque le GameServerGroup active l’état ACTIF, cela indique que GameLift FleetIQpeut modifier Amazon EC2 et Auto Scaling ressources dans votre compte, comme prévu.

Création d'un rôle pour Amazon EC2

Ce rôle permet à votre Amazon EC2 ressources pour communiquer avec GameLift FleetIQ. Par exemple,vos serveurs de jeux, qui s'exécutent sur des instances Amazon EC2, doivent être en mesure de signalerl'état de santé. Inclure ce rôle dans un IAM profil d’instance avec votre Amazon EC2 modèle de lancementlors de la création d’un GameLift FleetIQ groupe de serveurs de jeux.

Version233

Amazon GameLift Manuel du développeurConfigurez votre compte AWS

Utilisez l’interface de ligne de commande AWS pour créer un rôle pour Amazon EC2, joindre une stratégiepersonnalisée avec les autorisations nécessaires, et joindre le rôle à un profil d’instance. Pour plusd’informations, voir Créer un rôle pour un service AWS.

AWS CLI

Ces étapes décrivent comment créer un rôle de service avec une personnalisation GameLiftautorisations pour Amazon EC2 utiliser le AWS CLI.

1. Créez un fichier de stratégie d'approbation (exemple : FleetIQtrustpolicyEC2.json) avec lasyntaxe JSON suivante :

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

2. Créer un nouveau IAM rôle avec iam créer rôle et associez-le au fichier JSON de la politique trustque vous venez de créer.

Windows:

aws iam create-role --role-name FleetIQ-role-for-EC2 --assume-role-policy-document file://C:\policies\FleetIQtrustpolicyEC2.json

Linux*

aws iam create-role --role-name FleetIQ-role-for-EC2 --assume-role-policy-document file://policies/FleetIQtrustpolicyEC2.json

Lorsque la demande est réussie, la réponse inclut les propriétés du rôle nouvellement créé.Notez la valeur de l'ARN. Vous aurez besoin de ces informations lors de la configuration de votreAmazon EC2 lancer le modèle.

3. Créez un fichier de stratégie d'autorisations (exemple : FleetIQpermissionsEC2.json) avecla syntaxe JSON suivante :

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

4. Utiliser politique de mise en place de l’iam pour joindre le fichier JSON de la politiqued’autorisations, que vous venez de créer, au nouveau rôle.

Windows:Version

234

Amazon GameLift Manuel du développeur

aws iam put-role-policy --role-name FleetIQ-role-for-EC2 --policy-name FleetIQ-permissions-for-EC2 --policy-document file://C:\policies\FleetIQpermissionsEC2.json

Linux*

aws iam put-role-policy --role-name FleetIQ-role-for-EC2 --policy-name FleetIQ-permissions-for-EC2 --policy-document file://policies/FleetIQpermissionsEC2.json

Pour vérifier que la politique d’autorisations est jointe, appelez le politiques-role-role am avec lenom du nouveau rôle.

5. Créer un profil d’instance avec profil de création de iam-instance avec le nouveau rôle à utiliseravec Amazon EC2. Pour plus d’informations, voir Gestion des profils d’instance.

aws iam create-instance-profile --instance-profile-name FleetIQ-role-for-EC2

Lorsque la demande est réussie, la réponse inclut les propriétés du profil d’instance nouvellementcréé.

6. Utiliser profil d’ajout à l’instance d’iam pour joindre le rôle au profil d’instance.

aws iam add-role-to-instance-profile --role-name FleetIQ-role-for-EC2 --instance-profile-name FleetIQ-role-for-EC2

Le rôle et le profil sont maintenant prêts à être utilisés avec un Amazon EC2 lancer le modèle.

Démarrez avec GameLift FleetIQPour commencer à utiliser GameLift FleetIQ, vous devez disposer d’un serveur de jeux de travail quifonctionne dans un site ou Amazon EC2 environnement. Votre serveur de jeux peut être un processusunique qui gère une ou plusieurs sessions de jeu, génère des processus enfant ou s'exécute à l'intérieurd'un conteneur.

1. Obtenir un Compte AWS.

Si vous possédez déjà un ou plusieurs comptes AWS, choisissez le compte AWS pour lequel voussouhaitez utiliser GameLift FleetIQ. Ce compte et votre utilisateur/groupe d’utilisateurs doivent disposerdes autorisations nécessaires pour gérer votre Amazon EC2, Auto Scalinget d’autres ressources AWSutilisées avec votre jeu. Voir Mettre à jour les autorisations utilisateur IAM (p. 230) pour plus de détails.

2. Création des rôles IAM.

Créer des rôles qui permettent GameLift groupes de serveurs de jeux Amazon EC2 et Auto Scalingressources pour communiquer entre elles. Voir Configurez votre compte AWS pour GameLiftFleetIQ (p. 229) pour plus de détails.

3. Obtenez le SDK AWS et AWS CLI avec GameLift FleetIQ.• Téléchargez la dernière version du kit AWS SDK.• Obtenez et installez l'outil AWS Command Line Interface.• Afficher le Amazon GameLift Documentation de référence API.

4. Préparez votre serveur de jeux pour l'utiliser avec GameLift FleetIQ.

Ajoutez le kit SDK AWS à votre projet de serveur de jeux et ajoutez les appels suivants :Version

235

Amazon GameLift Manuel du développeur

• registergameserver(): Passez cet appel une fois lorsque le processus du serveur de jeux démarre etest prêt à accepter les joueurs.

• updategameserver(): Passez cet appel régulièrement pour signaler la santé et la présence de joueurssur votre serveur de jeu.

• deregistergameserver(): Passez cet appel une fois lorsque le serveur de jeu est terminé.

Ces API conservent GameLift FleetIQ mis à jour avec l’état actuel et l’utilisation de vos serveurs dejeu. Avec ces informations, GameLift FleetIQ peut fournir à votre système de matchmaking une listede serveurs de jeu viables, inoccupés et éviter également de mettre fin aux instances avec les joueurssur eux pendant l’équilibrage. Voir the section called “Intégrer un serveur de jeux” (p. 237) pour desconseils supplémentaires et des exemples.

5. Créez une Amazon Machine Image (AMI) Amazon EC2 avec votre serveur de jeux.

Créez une AMI avec votre logiciel de serveur de jeux et avec d'autres ressources d'exécution ouparamètres de configuration. Pour obtenir de l’aide, voir Amazon Machine Images (AMI) dans leAmazon EC2 Guide de l’utilisateur.

6. Créer un Amazon EC2 lancer le modèle.

Créez un modèle de lancement Amazon EC2 qui utilise votre AMI personnalisée et définit lesparamètres de réseau et de sécurité pour vos ressources d'hébergement. Le modèle de lancement doitréférencer le profil d'instance que vous avez créé (voir étape 2) avec les autorisations qui permettent àvotre serveur de jeu de communiquer avec GameLift FleetIQ. Vous n'avez pas besoin d'inclure de typesd'instance dans votre modèle de lancement. Cette opération aura lieu ultérieurement. Pour obtenir del’aide, voir Création d’un modèle de lancement dans le Amazon EC2 Guide de l’utilisateur.

Note

Avant d’utiliser un modèle de lancement avec GameLift FleetIQ, nous vous recommandonsvivement de configurer une Auto Scaling pour vérifier que la configuration du modèle et l’AMIsont déployés correctement.

7. Configuration GameLift FleetIQ ressources d’hébergement.

Dans chaque région où vous souhaitez déployer des serveurs de jeu, créez un groupe de serveurs dejeux en appelant groupe de créameservergroup(). Transmettez le modèle de lancement (contenantvotre AMI et vos paramètres de réseau et de sécurité personnalisés), le rôle IAM et une liste des typesd'instance sur lesquels votre jeu peut s'exécuter. Cette action définit un Auto Scaling de votre compteAWS GameLift FleetIQ peut modifier. Pour obtenir d'autres conseils et d'autres exemples, veuillezconsulter Gérer GameLift FleetIQ groupes de serveurs de jeux (p. 239).

8. Intégrer GameLift FleetIQ à votre client de jeu.

Ajoutez le kit SDK AWS à votre client de jeu, à votre matchmaker ou à un autre composant backendqui alloue la capacité du serveur de jeux. Selon votre type de jeu, votre matchmaker peut appelerjeux de listes() ou claimgameserver() pour obtenir la capacité du serveur et réserver un serveur de jeudisponible. Pour obtenir d'autres conseils et d'autres exemples, veuillez consulter Intégrer GameLiftFleetIQ dans un client de jeu (p. 238).

9. Augmentez la capacité de votre groupe Auto Scaling.

Au fur et à mesure que les instances sont allouées dans votre groupe Auto Scaling, elles lancent vosserveurs de jeux. Chaque serveur de jeux s'enregistre ensuite auprès de GameLift FleetIQ en tant quecapacité disponible, afin d'être répertorié ou demandé ultérieurement par votre matchmaker.

10.Testez votre jeu.

Appeler votre matchmaker et appeler ClaimGameServer pour demander la capacité du serveur.Transmettez l'adresse IP et le port obtenus aux clients de jeu afin qu'ils puissent se connecter auserveur de jeux.

Version236

Amazon GameLift Manuel du développeurIntégrer un serveur de jeux

Intégrer GameLift FleetIQ dans un serveur de jeuxCette rubrique décrit les tâches requises pour préparer votre projet de serveur de jeu à communiqueravec GameLift FleetIQ. Consulter GameLift FleetIQBonnes pratiques (p. 240) pour des conseilssupplémentaires.

Enregistrer les serveurs de jeuxLorsqu’un processus de serveur de jeux est lancé et prêt à accueillir des jeux en direct, il doit s’inscrireavec GameLift FleetIQ en appelant registergameserver(). L’inscription permet GameLift FleetIQ pourrépondre aux systèmes de matchmaking ou autres services à la clientèle lorsqu’ils demandent desinformations sur la capacité du serveur ou réclament un serveur de jeu. Lors de l'enregistrement, le serveurde jeux peut fournir à GameLift FleetIQ les données et les informations de connexion pertinentes duserveur de jeux, y compris le port et l'adresse IP qu'il utilise pour les connexions client entrantes.

aws gamelift register-game-server \ --game-server-id UniqueId-1234 \ --game-server-group-name MyLiveGroup \ --instance-id i-1234567890 \ --connection-info "1.2.3.4:123" \ --game-server-data "{\"key\": \"value\"}"

Mettre à jour le statut du serveur de jeuUne fois qu’un serveur de jeux est enregistré, il doit régulièrement signaler le statut de santé et d’utilisationafin de maintenir l’état de la capacité du serveur en synchronisation GameLift FleetIQ. État de santé etd’utilisation du rapport en appelant updategameserver(). Dans l’exemple ci-dessous, le serveur de jeusignale qu’il est en bonne santé et qu’il n’est actuellement pas occupé par des joueurs d’hébergement oupar gameplay.

aws gamelift update-game-server \ --game-server-group-name MyLiveGroup \ --game-server-id UniqueId-1234 \ --health-check HEALTHY \ --utilization-status AVAILABLE

État de santé

Si votre serveur de jeu dispose d’un mécanisme permettant de suivre le statut de santé, vous pouvezutiliser ce mécanisme pour déclencher une mise à jour de santé du serveur de jeux vers GameLift FleetIQ.

Statut d’utilisation

L’état d’utilisation du serveur de jeu est maintenu GameLift FleetIQ informés sur les serveurs de jeuxactuellement idéaux et disponibles pour les nouvelles sessions de jeu. Votre serveur de jeu doit avoir unmécanisme qui déclenche une mise à jour de statut d’utilisation GameLift FleetIQ. Par exemple, vouspouvez déclencher la mise à jour lorsque les joueurs se connectent au serveur de jeu ou lorsqu’unesession de jeu commence.

Lors du démarrage d’une session de jeu, les services client ou matchmaking revendiquent un serveur dejeu disponible (en appelant claimgameserver()), les joueurs rapides se connectent au serveur de jeu etdéclenchent le jeu de jeu pour démarrer le jeu. Ce processus est décrit dans Intégrer GameLift FleetIQdans un client de jeu (p. 238). Une « réclamation » du serveur de jeux est valide pendant 60 secondes, etle serveur de jeu doit pouvoir mettre à jour l’état d’utilisation avec cette fenêtre. Si le statut d’utilisation n’est

Version237

Amazon GameLift Manuel du développeurIntégrer un client de jeu

pas mis à jour, GameLift FleetIQ supprime la réclamation, suppose que le serveur de jeu est disponible etpeut réserver le serveur de jeu pour une autre demande de réclamation client.

aws gamelift update-game-server \ --game-server-group-name MyLiveGroup \ --game-server-id UniqueId-1234 \ --health-check HEALTHY \ --utilization-status UTILIZED

Désenregistrer les serveurs de jeuxLorsqu’un jeu se termine, le serveur de jeu doit se désenregistrer GameLift FleetIQ utiliserderegistergameserver().

aws gamelift deregister-game-server \ --game-server-group-name MyLiveGroup \ --game-server-id UniqueId-1234

Intégrer GameLift FleetIQ dans un client de jeuCette rubrique décrit les tâches requises pour préparer votre client de jeu ou le service de matchmaking àcommuniquer avec GameLift FleetIQ afin d’acquérir un serveur de jeu pour organiser une session de jeu.

Créez une méthode qui permet à votre client de jeu ou au matchmaker de demander une ressource deserveur de jeux pour les joueurs. Voici quelques options pour y parvenir :

• Demander à GameLift FleetIQ de choisir un serveur de jeux disponible. Cette option tire parti deGameLift FleetIQ d’optimisation pour utiliser des instances ponctuelles à faible coût et pour une mise àl’échelle automatique.

• Demander tous les serveurs de jeux disponibles et sélectionner un serveur à utiliser (processus souventappelé « répertorier et sélectionner »).

Laisser GameLift FleetIQ choisir un serveur de jeuPour avoir GameLift FleetIQ choisissez un serveur de jeu disponible, appelez claimgameserver() sansspécifier un ID de serveur de jeu. Dans ce scénario, GameLift FleetIQ applique sa logique pour trouverun serveur de jeux sur une instance qui est viable pour l'hébergement de jeux et optimisée pour la mise àl'échelle automatique.

aws gamelift claim-game-server \ --game-server-group-name MyLiveGroup

En réponse à une demande de réclamation, GameLift FleetIQ identifie le GameServer les données deconnexion, les informations de connexion et les données de jeu que les clients peuvent utiliser pour seconnecter au serveur de jeu. L'état de la demande du serveur de jeux est défini sur CLAIMED (DEMANDÉ)pendant 60 secondes. Votre serveur de jeu ou service client doit mettre à jour le statut du serveur de jeusur GameLift FleetIQ une fois que les joueurs se connectent ou que le jeu de jeu commence. Cela garantitque GameLift FleetIQ ne fournit pas ce serveur de jeu en réponse aux demandes ultérieures de capacitédu serveur de jeux. Mettre à jour le statut du serveur de jeu en appelant updategameserver().

aws gamelift update-game-server \ --game-server-group-name MyLiveGroup \ --game-server-id UniqueId-1234 \ --health-check HEALTHY \

Version238

Amazon GameLift Manuel du développeurGérer les groupes de serveurs de jeux.

--utilization-status UTILIZED

Choisissez votre propre serveur de jeuAvec la méthode « liste et sélection », votre client de jeu ou votre matchmaker demande une liste desserveurs de jeu disponibles en appelant jeux de listes(). Vous pouvez utiliser les données du serveur dejeux pour fournir des informations supplémentaires que les joueurs ou votre matchmaker peuvent utiliserlors de la sélection d'un serveur de jeux. Pour contrôler la façon dont les résultats sont retournés, vouspouvez demander des résultats paginés et trier les serveurs de jeu par date d’enregistrement. La demandesuivante renvoie 20 serveurs de jeux actifs et disponibles dans le groupe de serveurs de jeux spécifiés,triés par heure d’enregistrement avec les nouveaux serveurs de jeu répertoriés en premier.

aws gamelift list-game-servers \ --game-server-group-name MyLiveGroup \ --limit 20 \ --sort-order DESCENDING

Sur la base de la liste des serveurs de jeu disponibles, le service client ou matchmaking sélectionne unserveur de jeu et le demande en appelant claimgameserver() avec l’ID de serveur de jeu spécifique. Dansce scénario, GameLift FleetIQ n’exerce aucune logique d’optimisation de type instance, comme décrit dansGameLift FleetIQLogique (p. 219).

aws gamelift claim-game-server \ --game-server-group-name MyLiveGroup \ --game-server-id UniqueId-1234

Gérer GameLift FleetIQ groupes de serveurs de jeuxCette rubrique décrit les tâches requises pour configurer un GameLift FleetIQ groupe de serveurs de jeux.La création d’un groupe de serveurs de jeux déclenche la création d’un groupe EC2 Auto Scaling avectous les paramètres de configuration nécessaires, ainsi que la configuration à gérer GameLift FleetIQoptimisations pour l’hébergement de jeux.

Avant de pouvoir créer un groupe de serveurs de jeux, vous devez au minimum disposer des ressourcessuivantes préparées :

• Un modèle de lancement Amazon EC2 qui spécifie comment lancer des instances Amazon EC2 avecvotre serveur de jeux. Pour plus d’informations, voir Lancement d’une instance à partir d’un modèle delancement dans le Guide d’utilisation Amazon EC2.

• Un rôle IAM qui étend l’accès limité à votre compte AWS pour permettre à l’équipe des jeux de hasard decréer et d’interagir avec le groupe Auto Scaling. Pour plus d'informations, consultez Créer des rôles IAMpour l'interaction entre services (p. 231).

Créer un groupe de serveurs de jeuxPour créer un groupe de serveurs de jeux, appelez groupe de créameservergroup(). Cette opérationcrée une GameLift FleetIQ groupe de serveur de jeux et un groupe de mise à l’échelle automatiquecorrespondant. Lorsque vous créez le groupe de serveur de jeu, vous spécifiez des paramètres spécifiquesau jeu pour GameLift FleetIQ, y compris la stratégie d’équilibrage et les définitions de type d’instance. Vousfournissez également les paramètres de propriété initiale pour le groupe Auto Scaling.

L’exemple suivant déclenche la création d’un GameServerGroup spécifie les types c4.grand et c5.grandinstance et limite les instances du groupe à des instances ponctuelles uniquement, et un groupe d’échelleautomatique qui utilise le modèle de lancement spécifié pour le déploiement des instances et gère lacapcity du groupe dans les paramètres minimum et maximum à l’aide d’une politique d’échelonnage

Version239

Amazon GameLift Manuel du développeurBonnes pratiques

automatique de suivi cible. Après une courte période de provisionnement, un AutoScalingGroup laressource est créée, et GameServerGroup active un état ACTIF.

aws gamelift create-game-server-group \ --game-server-group-name MyLiveGroup \ --role-arn arn:aws:iam::123456789012:role/GameLiftGSGRole \ --min-size 1 \ --max-size 10 \ --game-server-protection-policy FULL_PROTECTION \ --balancing-strategy SPOT_ONLY \ --launch-template LaunchTemplateId=lt-012ab345cde6789ff \ --instance-definitions '[{"InstanceType": "c4.large"}, {"InstanceType": "c5.large"}]' \ --auto-scaling-policy '{"TargetTrackingConfiguration": {"TargetValue": 66}}'

Mettre à jour un groupe de serveur de jeuxVous pouvez mettre à jour les propriétés du groupe de serveur de jeux qui affectent la manière dontGameLift FleetIQ gère l’hébergement pour les serveurs de jeux, y compris les optimisations de typede ressource. Pour mettre à jour ces propriétés, appelez updategameservergroup(). Une fois que lesmodifications apportées au groupe de serveurs de jeux prennent effet, GameLift FleetIQ peut écrasercertaines propriétés du Auto Scaling groupe.

Pour toutes les autres propriétés du groupe Auto Scaling, comme MinSize, MaxSize, etLaunchTemplate, vous pouvez les modifier directement sur Auto Scaling groupe.

Dans l’exemple ci-dessous, les définitions de type d’instance sont mises à jour pour basculer sur les typesd’instances de grande taille c4.xgrand et c5.x.

aws gamelift update-game-server-group \ --game-server-group-name MyLiveGroup \ --instance-definitions '[{"InstanceType": "c4.xlarge"}, {"InstanceType": "c5.xlarge"}]'

Suivre les instances du groupe de serveurs de jeuxUne fois qu’un groupe de serveur de jeux et un groupe de mise à l’échelle automatique sont en coursd’exécution avec des instances déployées, vous pouvez suivre l’état des instances de serveur de jeuen appelant descriptionbegameserverinstances(). Utilisez cette fonction pour suivre les situations oùles instances sont viables et actives pour l’hébergement des serveurs de jeu, lorsqu’ils sont en état dedrainage (c’est-à-dire, à risque potentiel pour les interruptions de jeu), et lorsqu’ils sont en cours decessation d’emploi en raison d’une interruption d’instance de points. Pour plus d’informations sur l’état dugroupe de serveurs de jeux, voir Durée de vie d’un groupe de serveurs de jeux (p. 226).

GameLift FleetIQBonnes pratiquesGameLift FleetIQ est une couche logique de faible niveau qui vous aide à gérer Amazon EC2 ressourcespour l’hébergement de jeux. En particulier, GameLift FleetIQ optimise l’utilisation des instances ponctuellesviables pour l’hébergement des jeux en minimisant le risque que les sessions de jeu soient interrompues.La fonctionnalité d'hébergement de jeux de base permet d'assurer le suivi des serveurs de jeux disponibleset d'acheminer le gameplay vers des serveurs de jeux à faible coût et d'une viabilité élevée.

GameLift FleetIQ en tant que fonctionnalité autonome, ne fournit pas de fonctionnalités avancées quisont offertes avec le traitement complet GameLift qui utilise également FleetIQ pour minimiser lescoûts d’hébergement. Si vous avez besoin de fonctionnalités telles que la mise en correspondance,l’acheminement des joueurs basé sur la latence, la gestion des sessions de jeu et de la session de jeu, etla gestion des versions, jetez un œil aux GameLift solutions.

Version240

Amazon GameLift Manuel du développeurBonnes pratiques

Voici quelques bonnes pratiques qui peuvent vous aider à tirer le meilleur parti de GameLift FleetIQ.

• Utiliser GameLift FleetIQ pour les jeux basés sur la session. GameLift FleetIQ fonctionne mieuxlorsqu’il dirige constamment les joueurs sur des instances qui sont moins susceptibles d’avoir desinterruptions de session de jeu. Le maintien des sessions à long terme interfère avec le GameLift FleetIQd’équilibrage, ce qui augmente la probabilité que les sessions de jeux soient interrompues. Le fluxde travail idéal pour les joueurs consiste à passer de la mise en relation (ou sélection du serveur) augameplay. À la fin de la partie, les joueurs retournent à la mise en relation et sont routés vers un autreserveur de jeux sur une nouvelle instance. Nous vous recommandons d'utiliser GameLift FleetIQ pour lesjeux dont les sessions durent moins de deux heures.

• Fournissez de nombreux types d'instance qui pourront être choisis. Lorsque vous configurez un groupede serveurs de jeux, vous fournissez une liste de types d'instance à utiliser. Plus vous incluez de typesd'instance, plus GameLift FleetIQ dispose de flexibilité pour utiliser les instances Spot de viabilité élevéepour l'hébergement de jeux. Par exemple, vous pouvez répertorier plusieurs tailles dans la même familled'instances (c5.large, c5.xlarge, c5.2xlarge, c5.4xlarge). Avec des instances plus volumineuses, vouspouvez exécuter plus de serveurs de jeux sur chaque instance, ce qui peut réduire les coûts. Avec desinstances plus petites, la mise à l'échelle automatique peut réagir plus rapidement aux variations de lademande des joueurs. N’oubliez pas que la liste des types d’instances souhaités n’est pas prioritaire—unAuto Scaling utilisera un équilibre des types d’instances viables pour maintenir la résilience du groupe.

• Testez votre jeu sur tous les types d'instance. Assurez-vous que votre serveur de jeux s'exécutecorrectement sur chaque type d'instance configuré pour votre groupe de serveurs de jeux.

• Utilisez la pondération de la capacité des instances. Si vous configurez votre groupe de serveursde jeux de manière à ce qu'il utilise différentes tailles d'instance (telles que c5.2xlarge, c5.4xlarge,c5.12xlarge), incluez des informations de pondération de la capacité pour chaque type d'instance. Pourplus d’informations, voir Pondération des instances pour Amazon EC2 Auto Scaling dans le Amazon EC2Auto Scaling Guide de l'utilisateur.

• Placez vos sessions de jeux en utilisant GameLift FleetIQ. Lorsque vous placez des groupes de joueursavec des serveurs de jeux, utilisez GameLift API ClaimGameServer(). GameLift FleetIQ évite deplacer des joueurs sur des instances avec une probabilité plus élevée d’interruptions de session de jeu.

• Signalez l'état du serveur de jeux à GameLift FleetIQ. Signaler périodiquement le statut de santé etd’utilisation du serveur avec le GameLift API UpdateGameServer(). Maintenir un statut précis duserveur de jeu aide GameLift FleetIQ placez les jeux de hasard plus efficacement. Il permet égalementd’éviter de terminer les instances avec jeu actif pendant l’activité d’équilibrage des points.

• Configurez une stratégie de mise à l'échelle automatique. Vous pouvez créer une stratégie de mise àl'échelle du suivi des cibles qui préserve votre capacité d'hébergement en fonction de l'utilisation desjoueurs et de la demande anticipée. Le GameLift FleetIQ métrique PercentUtilizedGameServersest une mesure de la quantité de votre capacité d’hébergement actuellement utilisée. La plupart desjeux souhaitent conserver un tampon de serveurs de jeux inutilisés, ce qui permet aux nouveaux joueursd'entrer rapidement dans un jeu. Vous pouvez créer une stratégie de mise à l'échelle qui préserve unecertaine taille de tampon, en ajoutant ou en supprimant des instances en fonction de la fluctuation dela demande des joueurs. Pour plus d’informations, voir Politiques d’évolutivité de suivi cible dans leAmazon EC2 Auto Scaling Guide de l'utilisateur.

• Utilisez des comptes AWS différents pour les environnements de développement et de production. Laséparation de vos configurations de développement et de production sur différents comptes permet delimiter le risque de mauvaise configuration qui aurait une incidence sur les joueurs en ligne.

• Activez la protection des sessions de jeu pour les groupes de serveurs de jeux en production. Pourprotéger vos joueurs, activez la protection de la session de jeu et empêchez les sessions de jeu activesd’être arrêtées prématurément en raison de l’échelonnement ou de l’équilibrage des activités.

• Testez votre jeu sur EC2 avant de l'intégrer à GameLift FleetIQ. Nous vous recommandons decommencer par préparer votre jeu sur EC2 et affiner votre configuration. Vous pouvez ensuite créer ungroupe de serveurs de jeux en utilisant le même modèle de lancement et la même AMI.

Si vous utilisez Kubernetes, nous vous recommandons d'ajouter des instances EC2 standard à votrecluster Kubernetes, puis de créer un groupe de serveurs de jeux à l'aide du modèle de lancement quevous créez pour les nœuds de travail dans votre cluster Kubernetes. Si vous utilisez EKS, créez votre

Version241

Amazon GameLift Manuel du développeurSurveiller avec CloudWatch

cluster EKS et votre groupe de serveurs de jeux séparément. Pour le groupe de serveurs de jeux, utilisezl'AMI optimisée pour EKS avec les données utilisateur appropriées et la configuration du modèle delancement utilisée pour votre intégration EKS. Pour plus d’informations sur les nœuds des travailleursEKS et sur l’IAM optimisé, consultez le AMI Linux optimisé pour Amazon EKS guide.

• Utiliser la stratégie d’équilibrage du groupe de jeux ON_DEMAND_ONLY pour une disponibilité fiable duserveur de jeu. Avec cette stratégie d’équilibrage en vigueur, aucune instance ponctuelle n’est utilisée. Ils’agit d’un outil utile pour garantir la disponibilité du serveur lorsque vous en avez le plus besoin, commelors des lancements de fonctionnalités ou d’autres événements spéciaux. Vous pouvez faire défiler ungroupe de serveurs de jeux d’un Spot à une stratégie à la demande selon les besoins.

Consultez également les bonnes pratiques AWS suivantes :

• Bonnes pratiques relatives à . Amazon EC2• Bonnes pratiques relatives à . Amazon EC2 Auto Scaling

Surveillance d'GameLift FleetIQ avec AmazonCloudWatch

Utiliser Amazon CloudWatch mesures pour augmenter la capacité de votre instance, développer lestableaux de bord des opérations et déclencher l’alarme. GameLift FleetIQ en tant que solution autonomeémet un ensemble de Amazon CloudWatch de votre compte AWS. Voir également Surveillance de vosgroupes et instances à l’échelle automatique à l’aide de la montre Amazon Cloudwatch dans le AmazonEC2 Auto Scaling Guide de l'utilisateur.

• AvailableGameServers

• UtilizedGameServers

• DrainingAvailableGameServers

• DrainingUtilizedGameServers

• PercentUtilizedGameServers

• GameServerInterruptions

• InstanceInterruptions

GameLift FleetIQFonctionnalités de• Équilibrage optimisé des points. GameLift FleetIQ évalue périodiquement les types d’instances et

remplace les instances ponctuelles qui ne sont pas considérées comme viables en raison d’un risqueplus élevé d’interruptions de session de jeu. Au fur et à mesure que votre groupe Auto Scaling supprimed'anciennes instances et en démarre de nouvelles, il est actualisé en permanence avec des typesd'instances viables pour l'hébergement de jeux.

• Routage optimal des joueurs. GameLift FleetIQ Les API dirigent de nouvelles sessions de jeu sur lesinstances Spot les plus résilientes, où elles sont moins susceptibles d’être interrompues. De plus, lessessions de jeu sont conditionnées sur moins d’instances, ce qui améliore le Auto Scaling la capacité dugroupe à réduire les ressources inutiles et à réduire les coûts d’hébergement.

• Mise à l’échelle automatique basée sur l’utilisation du lecteur. GameLift FleetIQ données d’utilisation duserveur de jeux emits CloudWatch mesures. Vous pouvez utiliser ces métriques pour mettre à l'échelleautomatiquement vos ressources d'hébergement disponibles afin d'assurer le suivi de la demande réelledes joueurs et réduire les coûts d'hébergement.

• Gestion directe des instances Amazon EC2 dans votre propre compte AWS. Gardez le contrôle totalde votre Amazon EC2 et Auto Scaling groupes. Cela signifie que vous pouvez configurer des modèles

Version242

Amazon GameLift Manuel du développeurGameLift FleetIQFonctionnalités de

de lancement d'instance, gérer des configurations de groupe Auto Scaling et intégrer d'autres servicesAWS. Dans le cadre de son activité d’équilibrage des points, GameLift FleetIQ effectue des mises à jourpériodiques à certains Auto Scaling propriétés du groupe. Vous pouvez temporairement remplacer cesparamètres ou suspendre l'activité GameLift FleetIQ si nécessaire.

• Prise en charge de plusieurs formats exécutables de serveur de jeux. GameLift FleetIQ prend encharge tous les formats actuellement exécutés Amazon EC2, y compris Windows, Linux, conteneurs etKubernetes. Voir le Amazon EC2 FAQ pour obtenir une liste des systèmes d’exploitation et des temps delivraison pris en charge.

• Plusieurs types de ressources d'hébergement. Avec GameLift FleetIQ, vous avez accès à une grandevariété de types d’instances pour l’hébergement du serveur de jeux (la disponibilité varie selon larégion). Cela signifie que vous pouvez associer votre serveur de jeux à la combinaison appropriée deprocesseur, de mémoire, de stockage et de capacité réseau pour offrir une expérience de jeu optimale àvos joueurs.

• Portée mondiale. GameLift FleetIQ est disponible dans 15 régions, dont la Chine. Cela signifie quevous pouvez rendre vos serveurs de jeux accessibles aux joueurs en garantissant une latence de jeuminimum, où qu'ils soient. Voir Points d’extrémité de service gamelift pour une liste complète desrégions.

Version243

Amazon GameLift Manuel du développeurProtection des données

Sécurité dans Amazon GameLiftSi vous utilisez GameLift FleetIQ comme fonction autonome avec Amazon EC2, veuillez égalementconsulter Sécurité dans Amazon EC2 dans le Amazon EC2 Guide de l'utilisateur pour les instances Linux.

Chez AWS, la sécurité dans le cloud est notre priorité numéro 1. En tant que client AWS, vous bénéficiezde centres de données et d'architectures réseau conçus pour répondre aux exigences des organisationsles plus pointilleuses en termes de sécurité.

La sécurité est une responsabilité partagée entre AWS et vous-même. Le modèle de responsabilitépartagée décrit ceci comme la sécurité du cloud et la sécurité dans le cloud :

• La sécurité du cloud – AWS est responsable de la protection de l'infrastructure qui exécute des servicesAWS dans le cloud AWS. AWS vous fournit également les services que vous pouvez utiliser en toutesécurité. Des auditeurs tiers testent et vérifient régulièrement l'efficacité de notre sécurité dans lecadre des programmes de conformité AWS. Pour en savoir plus sur les programmes de conformité quis'appliquent à Amazon GameLift, veuillez consulter Services AWS concernés par le programme deconformité.

• Sécurité dans le cloud – Votre responsabilité est déterminée par le service AWS que vous utilisez. Vousêtes également responsable d'autres facteurs, y compris la sensibilité de vos données, les exigences devotre entreprise,et la législation et la réglementation applicables.

Cette documentation vous aide à comprendre comment appliquer le modèle de responsabilité partagéelors de l'utilisation de GameLift. Les rubriques suivantes vous montrent comment configurer GameLift pourrépondre à vos objectifs de sécurité et de conformité. Vous pouvez également apprendre à utiliser d'autresservices AWS qui vous permettent de surveiller et de sécuriser vos ressources GameLift.

Rubriques• Protection des données dans GameLift (p. 244)• Identity and Access Management pour GameLift (p. 246)• Journalisation et surveillance avec GameLift (p. 260)• Validation de la conformité pour GameLift (p. 260)• Résilience dans GameLift (p. 261)• Sécurité de l'infrastructure dans GameLift (p. 262)• Configuration et analyse des vulnérabilités dans GameLift (p. 262)• Bonnes pratiques de sécurité pour Amazon GameLift (p. 263)

Protection des données dans GameLiftSi vous utilisez GameLift FleetIQ comme fonction autonome avec Amazon EC2, veuillez égalementconsulter Sécurité dans Amazon EC2 dans le Amazon EC2 Guide de l'utilisateur pour les instances Linux.

Le modèle de responsabilité partagée AWS s'applique à la protection des données dans Amazon GameLift.Comme décrit dans ce modèle, AWS est responsable de la protection de l'infrastructure globale surlaquelle l'ensemble du cloud AWS s’exécute. La gestion du contrôle de votre contenu hébergé sur cetteinfrastructure est de votre responsabilité. Ce contenu comprend les tâches de configuration et de gestionde la sécurité des services AWS que vous utilisez. Pour plus d'informations sur la confidentialité des

Version244

Amazon GameLift Manuel du développeurProtection des données

données, veuillez consulter FAQ sur la confidentialité des données. Pour plus d'informations sur laprotection des données en Europe, veuillez consulter le billet de blog AWSShared Responsibility Model andGDPR sur la page AWSSecurity Blog.

À des fins de protection des données, nous vous recommandons de protéger les informationsd'identification du compte AWS et de configurer les comptes d'utilisateur individuels avec AWS Identityand Access Management (IAM). Ainsi, chaque utilisateur se voit attribuer uniquement les autorisationsnécessaires pour exécuter ses tâches. Nous vous recommandons également de sécuriser vos donnéescomme indiqué ci-dessous :

• Utilisez l'authentification multi-facteurs (MFA) avec chaque compte.• Utilisez SSL/TLS pour communiquer avec des ressources AWS. Nous recommandons TLS 1.2 ou

version ultérieure.• Configurez l'API et la consignation des activités utilisateur avec AWS CloudTrail.• Utilisez des solutions de chiffrement AWS, ainsi que tous les contrôles de sécurité par défaut au sein des

services AWS.• Utilisez des services de sécurité gérés comme Amazon Macie, qui contribue à la découverte et à la

sécurisation des données personnelles stockées dans Amazon S3.• Si vous avez besoin de modules cryptographiques validés FIPS 140-2 lorsque vous accédez à AWS

via une interface de ligne de commande ou une API, utilisez un point de terminaison FIPS. Pour deplus amples informations sur les points de terminaison FIPS disponibles, consultez Federal InformationProcessing Standard (FIPS) 140-2.

Nous vous recommandons vivement de ne jamais placer d'informations identifiables sensibles, telles quedes numéros de compte de vos clients, dans des champs de formulaire comme Nom. Cela inclut lorsquevous utilisez GameLift ou d'autres services AWS à l'aide de la console, de l'API, de l'interface de lignede commande (AWS CLI) ou des kits SDK AWS. Toutes les données que vous entrez dans GameLift oud'autres services peuvent être récupérées pour être insérées dans des journaux de diagnostic. Lorsquevous fournissez une URL à un serveur externe, n'incluez pas les informations d'identification non chiffréesdans l'URL pour valider votre demande adressée au serveur.

Les données spécifiques à GameLift sont traitées comme suit :

• Les builds et les scripts de serveur de jeu que vous chargez dans GameLift sont stockés dans AmazonS3. Il n'y a pas d'accès client direct à ces données une fois qu'elles sont chargées. Un utilisateur autorisépeut obtenir un accès temporaire pour charger des fichiers, mais il ne peut pas afficher ou mettre à jources derniers directement dans Amazon S3. Pour supprimer des scripts et des builds, utilisez la consoleGameLift ou l'API du service.

• Les données du journal de session de jeu sont stockées dans Amazon S3 pendant un temps limité aprèsla fin de la session de jeu. Les utilisateurs autorisés peuvent accéder aux données du journal en lestéléchargeant via un lien dans la console GameLift ou des appels à l'API du service.

• Les données de métriques et d'événement sont stockées dans GameLift et sont accessibles via laconsole GameLift ou des appels à l'API du service. Les données pouvant être récupérées concernentles parcs, les instances, les placements de session de jeu, les tickets de mise en relation, les sessionsde jeu et les sessions de joueur. Les données sont également accessibles via Amazon CloudWatch etCloudWatch Events.

• Les données fournies par le client sont stockées dans GameLift. Les utilisateurs autorisés peuvent yaccéder via des appels à l'API du service. Les données potentiellement sensibles peuvent inclure desdonnées de joueur, des données de session de joueur et de session de jeu (y compris les informationsde connexion), des données de mise en relation, etc.

Note

Si vous fournissez un joueur personnalisé IDs dans vos demandes, ces valeurs doivent êtreanonymisées UUIDs et ne contenir aucune information d'identification de joueur.

Version245

Amazon GameLift Manuel du développeurChiffrement au repos

Pour de plus amples informations sur la protection des données, veuillez consulter le billet de blog Modèlede responsabilité partagée AWS et RGPD sur le Blog sur la sécurité d'AWS.

Chiffrement au reposLe chiffrement au repos des données spécifiques à GameLift est géré comme suit :

• Les builds et les scripts de serveur de jeu sont stockés dans des compartiments Amazon S3 avecchiffrement côté serveur.

• Les données fournies par le client sont stockées dans GameLift selon un format chiffré.

Chiffrement en transitLes connexions aux API GameLift sont établies via une connexion sécurisée (SSL) et authentifiées à l'aided' AWS Signature Version 4 (lors de la connexion via l'AWS CLI ou le kit SDK AWS, la signature est géréeautomatiquement). L'authentification est gérée à l'aide des stratégies d'accès définies par IAM pour lesinformations d'identification de sécurité utilisées pour établir la connexion.

La communication directe entre les clients de jeu et les serveurs de jeu est la suivante :

• Pour les serveurs de jeux personnalisés hébergés sur des ressources GameLift, la communicationn'implique pas le service GameLift. Le chiffrement de cette communication est de la responsabilitédu client. Vous pouvez utiliser des parcs compatibles TLS pour que vos clients de jeu authentifient leserveur de jeu lors de la connexion et chiffrent toutes les communications entre votre client de jeu etvotre serveur de jeu.

• Pour Serveurs en temps réel avec la génération de certificats TLS activée, le trafic entre le client dejeu et les serveurs RealTime utilisant le kit SDK RealTime Client est chiffré à la volée. Le trafic TCP estchiffré avec TLS 1.2 et le trafic UDP avec DTLS 1.2.

Confidentialité du trafic inter-réseauxVous pouvez accéder à distance à vos instances GameLift en toute sécurité. Pour les instances qui utilisentLinux, SSH fournit un canal de communication sécurisé pour l'accès à distance. Pour les instances quiexécutent Windows, utilisez un client RDP (Remote Desktop Protocol). Avec GameLift FleetIQ, l'accès àdistance à vos instances via AWS Systems Manager Session Manager et Run Command est chiffré à l'aidede TLS 1.2, et les demandes de création d'une connexion sont chiffrées à l'aide de SigV4. Pour obtenir del'aide sur la connexion à une instance GameLift gérée, veuillez consulter Accès à distance aux instancesde flotte GameLift (p. 130).

Identity and Access Management pour GameLiftAWS Identity and Access Management (IAM) est un service AWS qui permet à un administrateur decontrôler en toute sécurité l'accès aux ressources AWS. Les administrateurs IAM contrôlent qui peut êtreauthentifié (connecté) et autorisé (disposant des autorisations) à utiliser les ressources GameLift. IAM estun service AWS que vous pouvez utiliser sans frais supplémentaires.

Rubriques• Audience (p. 247)• Authentification avec des identités (p. 247)• Gestion de l'accès à l'aide de stratégies (p. 249)

Version246

Amazon GameLift Manuel du développeurAudience

• Comment GameLift fonctionne avec IAM (p. 251)• GameLiftExemples de stratégies basées sur l'identité (p. 255)• Dépannage GameLift identité et accès (p. 258)

AudienceVotre utilisation d'AWS Identity and Access Management (IAM) évolue selon la tâche que vous réalisezdans GameLift.

Utilisateur du service – Si vous utilisez le service GameLift pour effectuer votre tâche, votre administrateurvous fournit les informations d'identification et les autorisations dont vous avez besoin. Plus vous utiliserezde fonctionnalités GameLift pour effectuer votre travail, plus vous pourrez avoir besoin d'autorisationssupplémentaires. Comprendre la gestion des accès peut vous aider à demander à votre administrateur lesautorisations appropriées. Si vous ne pouvez pas accéder à une fonctionnalité dans GameLift, consultezDépannage GameLift identité et accès (p. 258).

Administrateur du service –Si vous êtes le responsable des ressources GameLift de votre entreprise,vous bénéficiez probablement d'un accès total à GameLift. C'est à vous de déterminer les fonctionnalitéset les ressources GameLift auxquelles vos employés pourront accéder. Vous devez ensuite soumettreles demandes à votre administrateur IAM pour modifier les autorisations des utilisateurs de votre service.Consultez les informations sur cette page pour comprendre les concepts de base d'IAM. Pour en savoirplus sur la façon dont votre entreprise peut utiliser IAM avec GameLift, consultez Comment GameLiftfonctionne avec IAM (p. 251).

Administrateur IAM – Si vous êtes un administrateur IAM, vous souhaiterez peut-être obtenir des détailssur la façon dont vous pouvez écrire des stratégies pour gérer l'accès à GameLift. Pour obtenir desexemples de stratégies GameLift basées sur l'identité que vous pouvez utiliser dans IAM, consultezGameLiftExemples de stratégies basées sur l'identité (p. 255).

Authentification avec des identitésL'authentification correspond au processus par lequel vous vous connectez à AWS via vos informationsd'identification. Pour de plus amples informations sur la connexion avec AWS Management Console,veuillez consulter Connexion à AWS Management Console en tant qu'utilisateur IAM ou utilisateur racinedans le IAM Guide de l'utilisateur.

Vous devez être authentifié (connecté à AWS) en tant que Utilisateur racine d'un compte AWS ouutilisateurIAM, ou en assumant un rôle IAM. Vous pouvez également utiliser l'authentification de connexionunique de votre entreprise ou vous connecter par le biais de Google ou de Facebook. Dans ce cas, votreadministrateur aura précédemment configuré une fédération d’identités avec des rôles IAM. Lorsque vousaccédez à AWS avec des informations d’identification d’une autre entreprise, vous assumez indirectementun rôle.

Pour vous connecter directement à AWS Management Console, utilisez votre mot de passe avec votree-mail utilisateur racine ou votre nom d'utilisateur IAM. Vous pouvez accéder à AWS par programmationavec vos clés d'accès utilisateur utilisateur racine ou IAM. AWS fournit un kit SDK et des outils de ligne decommande pour signer de manière chiffrée votre demande avec vos informations d'identification. Si vousn'utilisez pas les outils AWS, vous devez signer la requête vous-même. Pour ce faire, utilisez SignatureVersion 4, un protocole permettant d'authentifier les demandes d'API entrantes. Pour en savoir plus surl'authentification des demandes, consultez Processus de signature Signature Version 4 dans AWS GeneralReference.

Quelle que soit la méthode d'authentification que vous utilisez, vous devrez peut-être également fournir desinformations de sécurité supplémentaires. Par exemple, AWS vous recommande d'utiliser l'authentificationmulti-facteurs (MFA) pour améliorer la sécurité de votre compte. Pour en savoir plus, consultez Utilisationde Multi-Factor Authentication (MFA) dans AWS dans le IAM Guide de l'utilisateur.

Version247

Amazon GameLift Manuel du développeurAuthentification avec des identités

Utilisateur racine d'un compte AWSLorsque vous créez un compte AWS, vous commencez avec une seule identité de connexion disposantd'un accès complet à tous les services et ressources AWS du compte. Cette identité est appelée lautilisateur racinedu compte AWS et elle est accessible après connexion à l'aide de l'adresse e-mail et dumot de passe utilisés pour la création du compte. Il est vivement recommandé de ne pas utiliser l'utilisateurracine pour vos tâches quotidiennes, y compris pour les tâches administratives. Au lieu de cela, respectezla bonne pratique qui consiste à avoir recours à l'utilisateur racine uniquement pour créer le premierutilisateurIAM. Ensuite, mettez en sécurité les informations d'identification de l'utilisateur racine et utilisez-les pour effectuer uniquement certaines tâches de gestion des comptes et des services.

IAMUtilisateurs et groupesUn utilisateur IAM est une identité dans votre compte AWS qui dispose d'autorisations spécifiques pourune seule personne ou application. Un utilisateur IAM peut disposer d'informations d'identification à longterme comme un nom d'utilisateur et un mot de passe ou un ensemble de clés d'accès. Pour savoircomment générer des clés d'accès, consultez Gestion des clés d’accès pour les utilisateurs IAM dans leIAM Guide de l'utilisateur. Lorsque vous générez des clés d'accès pour un utilisateur IAM, veillez à afficheret enregistrer la paire de clés de manière sécurisée. Vous ne pourrez plus récupérer la clé d'accès secrèteà l'avenir. Au lieu de cela, vous devrez générer une nouvelle paire de clés d'accès.

Un groupe IAM est une identité qui spécifie un ensemble d’utilisateurs IAM. Vous ne pouvez pas vousconnecter en tant que groupe. Vous pouvez utiliser les groupes pour spécifier des autorisations pourplusieurs utilisateurs à la fois. Les groupes permettent de gérer plus facilement les autorisations pourde grands ensembles d'utilisateurs. Par exemple, vous pouvez avoir un groupe nommé Admins IAM etaccorder à ce groupe les autorisations leur permettant d'administrer des ressources IAM.

Les utilisateurs sont différents des rôles. Un utilisateur est associé de manière unique à une personneou une application, alors qu’un rôle est conçu pour être endossé par tout utilisateur qui en a besoin.Les utilisateurs disposent d'informations d'identification permanentes, mais les rôles fournissent desinformations d'identification temporaires. Pour en savoir plus, consultez Quand créer un utilisateur IAM (aulieu d'un rôle) dans le IAM Guide de l'utilisateur.

IAMRôlesUn rôle IAM est une entité au sein de votre compte AWS qui dispose d'autorisations spécifiques. Leconcept ressemble à celui d’utilisateur IAM, mais un rôle n'est pas associé à une personne en particulier.Vous pouvez temporairement endosser un rôle IAM dans l’AWS Management Console grâce auchangement de rôle. Vous pouvez obtenir un rôle en appelant une opération d’API AWS CLI ou AWS àl'aide d'une URL personnalisée. Pour plus d'informations sur les méthodes d'utilisation des rôles, consultezUtilisation de rôles IAM dans le IAM Guide de l'utilisateur.

Les rôles IAM avec des informations d'identification temporaires sont utiles dans les cas suivants :

• Autorisations utilisateur IAM temporaires – Un utilisateur IAM peut endosser un rôle IAM pour accepterdifférentes autorisations temporaires concernant une tâche spécifique.

• Accès d'utilisateurs fédérés – Au lieu de créer un utilisateur IAM, vous pouvez utiliser des identitésd'utilisateur préexistantes provenant d'AWS Directory Service, de l'annuaire d'utilisateurs de votreentreprise ou d'un fournisseur d'identité web. On parle alors d'utilisateurs fédérés. AWS attribue un rôleà un utilisateur fédéré lorsque l'accès est demandé via un fournisseur d'identité. Pour de plus amplesinformations sur les utilisateurs fédérés, veuillez consulter Utilisateurs et rôles fédérés dans le IAM Guidede l'utilisateur.

• Accès entre comptes – Vous pouvez utiliser un rôle IAM pour permettre à un utilisateur (mandatairede confiance) d'un compte différent d'accéder aux ressources de votre compte. Les rôles constituentle principal moyen d'accorder l'accès entre plusieurs comptes. Toutefois, certains services AWS vouspermettent d'attacher une stratégie directement à une ressource (au lieu d'utiliser un rôle en tant que

Version248

Amazon GameLift Manuel du développeurGestion de l'accès à l'aide de stratégies

proxy). Pour en savoir plus sur la différence entre les rôles et les stratégies basées sur les ressourcespour l'accès entre comptes, consultez Différence entre les rôles IAM et les stratégies basées sur lesressources dans le IAM Guide de l'utilisateur.

• Accès inter-service – Some AWS services use features in other AWS services. For example, when youmake a call in a service, it's common for that service to run applications in Amazon EC2 or store objectsin Amazon S3. A service might do this using the calling principal's permissions, using a service role, orusing a service-linked role.• Autorisations principales – When you use an IAM user or role to perform actions in AWS, you are

considered a principal. Policies grant permissions to a principal. When you use some services, youmight perform an action that then triggers another action in a different service. In this case, you musthave permissions to perform both actions. To see whether an action requires additional dependentactions in a policy, see Actions, Resources, and Condition Keys for Amazon GameLift in the ServiceAuthorization Reference.

• Rôle de service –Un rôle de service est un rôle IAM qu'un service assume pour exécuter des actionsen votre nom. Les rôles de service fournissent un accès uniquement au sein de votre compteet ne peuvent pas être utilisés pour accorder l'accès à des services dans d'autres comptes. Unadministrateur IAM peut créer, modifier et supprimer un rôle de service à partir d'IAM. Pour de plusamples informations, veuillez consulter Création d'un rôle pour la délégation d'autorisations à unservice AWS dans le IAM Guide de l'utilisateur.

• Rôle lié à un service – A service-linked role is a type of service role that is linked to an AWS service.The service can assume the role to perform an action on your behalf. Service-linked roles appearin your IAM account and are owned by the service. An IAM administrator can view, but not edit thepermissions for service-linked roles.

• Applications qui s'exécutent sur Amazon EC2 –Vous pouvez utiliser un rôle IAM pour gérer desinformations d'identification temporaires pour les applications qui s'exécutent sur une instance EC2 eteffectuent des demandes d'API AWS CLI ou AWS. Cette solution est préférable au stockage des clésd'accès au sein de l'instance EC2. Pour attribuer un rôle AWS à une instance EC2 et le rendre disponibleà toutes les applications associées, vous pouvez créer un profil d'instance attaché à l'instance. Un profild'instance contient le rôle et permet aux programmes qui s'exécutent sur l'instance EC2 d'obtenir desinformations d'identification temporaires. Pour de plus amples informations, veuillez consulter Utilisationd'un rôle IAM pour accorder des autorisations à des applications s'exécutant sur des instances AmazonEC2 dans le IAM Guide de l'utilisateur.

Pour savoir si vous devez utiliser les rôles IAM ou les utilisateurs IAM, veuillez consulter Quand créer unrôle IAM (au lieu d'un utilisateur) dans le IAM Guide de l'utilisateur.

Gestion de l'accès à l'aide de stratégiesVous contrôler les accès dans AWS en créant des stratégies et en les attachant à des identités IAM ouà des ressources AWS. Une stratégie est un objet dans AWS qui, lorsqu'il est associé à une identité ouà une ressource, définit ses autorisations. Vous pouvez vous connecter en tant que utilisateur racine,en tant qu'utilisateur IAM ou vous pouvez assumer un rôle IAM. Lorsque vous effectuez ensuite unedemande, AWS évalue les stratégies relatives basées sur l'identité ou les ressources. Les autorisationsdans les stratégies déterminent si la demande est autorisée ou refusée. La plupart des stratégies sontstockées dans AWS en tant que documents JSON. Pour plus d'informations sur la structure et le contenudu document de stratégie JSON, consultez Présentation des stratégies JSON dans le IAM Guide del'utilisateur.

Administrators can use AWS JSON policies to specify who has access to what. That is, which principal canperform actions on what resources, and under what conditions.

Chaque entité IAM (utilisateur ou rôle) démarre sans autorisation. En d'autres termes, par défaut, lesutilisateurs ne peuvent rien faire, pas même changer leurs propres mots de passe. Pour autoriser unutilisateur à effectuer une opération, un administrateur doit associer une stratégie d'autorisations à cedernier. Il peut également ajouter l'utilisateur à un groupe disposant des autorisations prévues. Lorsqu'un

Version249

Amazon GameLift Manuel du développeurGestion de l'accès à l'aide de stratégies

administrateur accorde des autorisations à un groupe, tous les utilisateurs de ce groupe se voient octroyerces autorisations.

Les stratégies IAM définissent les autorisations d'une action quelle que soit la méthode que vous utilisezpour exécuter l'opération. Par exemple, supposons que vous disposiez d'une stratégie qui autorise l'actioniam:GetRole. Un utilisateur avec cette stratégie peut obtenir des informations utilisateur à partir de l'AWSManagement Console, de l'AWS CLI ou de l'API AWS.

Stratégies basées sur l'identitéIdentity-based policies are JSON permissions policy documents that you can attach to an identity, such asan IAM user, group of users, or role. These policies control what actions users and roles can perform, onwhich resources, and under what conditions. To learn how to create an identity-based policy, see CreatingIAM policies in the IAM Guide de l'utilisateur.

Les stratégies basées sur l'identité peuvent être classées comme étant des stratégies en ligne ou desstratégies gérées. Les stratégies en ligne sont intégrées directement à un utilisateur, groupe ou rôle. Lesstratégies gérées sont des stratégies autonomes que vous pouvez lier à plusieurs utilisateurs, groupes etrôles de votre compte AWS. Les stratégies gérées incluent les stratégies gérées par AWS et les stratégiesgérées par le client. Pour découvrir comment choisir entre une politique gérée ou une politique en ligne,consultez Choix entre les stratégies gérées et les stratégies en ligne dans le IAM Guide de l'utilisateur.

Stratégies basées sur les ressourcesResource-based policies are JSON policy documents that you attach to a resource. Examples of resource-based policies are IAM role trust policies and Amazon S3 bucket policies. In services that support resource-based policies, service administrators can use them to control access to a specific resource. For theresource where the policy is attached, the policy defines what actions a specified principal can perform onthat resource and under what conditions. You must specify a principal in a resource-based policy. Principalscan include accounts, users, roles, federated users, or AWS services.

Les stratégies basées sur les ressources sont des stratégies en ligne situées dans ce service. Vous nepouvez pas utiliser les stratégies gérées AWS depuis IAM dans une stratégie basée sur les ressources.

Listes de contrôle d'accès (ACL)Access control lists (ACLs) control which principals (account members, users, or roles) have permissions toaccess a resource. ACLs are similar to resource-based policies, although they do not use the JSON policydocument format.

Amazon S3, AWS WAF et Amazon VPC sont des exemples de services qui prennent en charge leslistes de contrôle d'accès (ACL). Pour en savoir plus sur les listes de contrôle d'accès, veuillez consulterPrésentation des listes de contrôle d'accès (ACL) dans le Guide du développeur Amazon Simple StorageService.

Autres types de stratégieAWS prend en charge d'autres types de stratégies moins courantes. Ces types de stratégies peuventdéfinir le nombre maximal d'autorisations qui vous sont accordées par des types de stratégies pluscourants.

• Limite d'autorisations – Une limite d'autorisations est une fonctionnalité avancée dans laquelle vousdéfinissez les autorisations maximales qu'une stratégie basée sur l'identité peut accorder à uneentité IAM (utilisateur ou rôle IAM). Vous pouvez définir une limite d'autorisations pour une entité. Lesautorisations obtenues représentent la combinaison des stratégies basées sur l'identité de l'entité et deses limites d'autorisations. Les stratégies basées sur les ressources qui spécifient l'utilisateur ou le rôledans le champ Principal ne sont pas limitées par les limites d'autorisations. Un refus explicite dans

Version250

Amazon GameLift Manuel du développeurComment GameLift fonctionne avec IAM

l'une de ces stratégies remplace l'autorisation. Pour plus d'informations sur les limites d'autorisations,consultez Limites d'autorisations pour des entités IAM dans le IAM Guide de l'utilisateur.

• Stratégies de contrôle de service (SCP) – Les SCP sont des stratégies JSON qui spécifient lenombre maximal d'autorisations pour une organisation ou une unité d'organisation (OU) dans AWSOrganizations. AWS Organizations est un service qui vous permet de regrouper et de gérer de façoncentralisée plusieurs comptes AWS détenus par votre entreprise. Si vous activez toutes les fonctionsd'une organisation, vous pouvez appliquer les stratégies de contrôle de service (SCP) à l'un ou àl'ensemble de vos comptes. La politique de contrôle des services limite les autorisations pour les entitésdans les comptes membres, y compris dans chaque Utilisateur racine d'un compte AWS. Pour plusd'informations sur les Organisations et les SCP, consultez Fonctionnement des stratégies de contrôle deservice dans le Manuel de l'utilisateur AWS Organizations.

• Stratégies de session – Les stratégies de session sont des stratégies avancées que vous transmettezen tant que paramètre lorsque vous créez par programmation une session temporaire pour un rôleou un utilisateur fédéré. Les autorisations de la session obtenue sont une combinaison des stratégiesbasées sur l'identité de l'utilisateur ou du rôle et des stratégies de session. Les autorisations peuventégalement provenir d'une stratégie basée sur les ressources. Un refus explicite dans l'une de cesstratégies remplace l'autorisation. Pour plus d'informations, consultez Stratégies de session dans le IAMGuide de l'utilisateur.

Plusieurs types de stratégieLorsque plusieurs types de stratégies s'appliquent à la requête, les autorisations obtenues sont pluscompliquées à comprendre. Pour découvrir la façon dont AWS détermine s'il convient d'autoriser unerequête en présence de plusieurs types de stratégies, consultez Logique d'évaluation de stratégies dans leIAM Guide de l'utilisateur.

Comment GameLift fonctionne avec IAMAvant d’utiliser IAM pour gérer l’accès à GameLift, vous devez comprendre IAM sont disponibles avecGameLift. Pour obtenir une vision de haut niveau de la manière dont GameLift et autres AWS services avecIAM, voir AWS Des services qui fonctionnent avec IAM dans le IAM Guide de l'utilisateur.

Si vous utilisez GameLift FleetIQ comme fonction autonome avec Amazon EC2, veuillez égalementconsulter Sécurité dans Amazon EC2 dans le Amazon EC2 Guide de l'utilisateur pour les instances Linux.

GameLiftStratégies basées sur l'identitéAvec IAM les politiques basées sur l’identité, vous pouvez spécifier les actions et ressources autoriséesou refusées ainsi que les conditions dans lesquelles les actions sont autorisées ou refusées. GameLiftprend en charge des actions, ressources et clés de condition spécifiques. Pour en savoir plus sur tous leséléments que vous utilisez dans une politique JSON, consultez IAM Référence des éléments de la politiqueJSON dans le IAM Guide de l'utilisateur.

Actions

Administrators can use AWS JSON policies to specify who has access to what. That is, which principal canperform actions on what resources, and under what conditions.

L'élément Action d'une stratégie JSON décrit les actions que vous pouvez utiliser pour autoriser ourefuser l'accès à une stratégie. Les actions de stratégie possèdent généralement le même nom quel'opération d'API AWS associée. Il existe quelques exceptions, telles que les actions avec autorisationsuniquement qui n'ont pas d'opération API correspondante. Certaines opérations nécessitent égalementplusieurs actions dans une stratégie. Ces actions supplémentaires sont nommées actions dépendantes.

Intégration d'actions dans une stratégie afin d'accorder l'autorisation d'exécuter les opérations associées.

Version251

Amazon GameLift Manuel du développeurComment GameLift fonctionne avec IAM

Les actions de stratégie dans le GameLift utilisent le préfixe suivant avant l'action : .gamelift:. Par exemple, accorder l’autorisation de demander une nouvelle session de jeuavec le GameLiftStartGameSessionPlacement Le fonctionnement de l’API, vous incluezgamelift:StartGameSessionPlacement dans leur politique. Les déclarations de politique doiventinclure soit un Action ou NotAction. GameLift définit son propre ensemble d’actions qui décrivent lestâches que vous pouvez exécuter avec ce service.

Pour spécifier plusieurs actions dans une seule déclaration, séparez-les par des virgules comme suit.

"Action": [ "gamelift:action1", "gamelift:action2"

Vous pouvez aussi spécifier plusieurs actions à l'aide de caractères génériques (*). Par exemple, pourspécifier toutes les actions qui commencent par le mot Describe, incluez l'action suivante.

"Action": "gamelift:Describe*"

Pour afficher une liste de GameLift actions, voir Actions définies par Amazon GameLift dans le IAM Guidede l'utilisateur.

Les actions GameLift suivantes ont des dépendances d'autorisation supplémentaires :

• Actions de peering VPC CreateVpcPeeringAuthorization et CreateVpcPeeringConnectionnécessite un accès au VPC pertinent. Le VPC peut appartenir au compte AWS que vous utilisez pourgérer GameLift, ou à un autre compte AWS. Pour de plus amples informations sur l'appairage de VPCavec GameLift, veuillez consulter Homologation VPC pour GameLift (p. 187).

• Le GameLift FleetIQ actions, y compris CreateGameServerGroup, nécessite un accès à certainsAmazon EC2, Auto Scaling, et autres actions connexes. Pour plus d’informations sur la configurationIAM autorisations d’utilisation avec GameLift FleetIQ, voir Mettre à jour les autorisations utilisateurIAM (p. 230) dans le GameLift FleetIQ Guide.

Resources

Administrators can use AWS JSON policies to specify who has access to what. That is, which principal canperform actions on what resources, and under what conditions.

L'élément de stratégie JSON Resource indique le ou les objets pour lesquels l'action s'applique. Lesinstructions doivent inclure un élément Resource ou NotResource. Au titre de bonne pratique, il estrecommandé de définir une ressource à l'aide de son Amazon Resource Name (ARN). Vous pouvezle faire pour les actions qui sont compatibles avec un type de ressource spécifique, connu sous ladénomination autorisations de niveau ressource.

Pour les actions qui ne sont pas compatibles avec les autorisations de niveau ressource, telles que lesopérations de liste, utilisez un caractère générique (*) afin d'indiquer que l'instruction s'applique à toutes lesressources.

"Resource": "*"

Les ressources GameLift de longue durée ont des valeurs d'ARN, ce qui permet que l'accès à cesressources soit géré à l'aide de stratégies IAM. L'ARN de la ressource de parc GameLift respecte lasyntaxe suivante :

arn:${Partition}:gamelift:${Region}:${Account}:fleet/${FleetId}

Version252

Amazon GameLift Manuel du développeurComment GameLift fonctionne avec IAM

Pour plus d’informations sur le format des arns, voir Noms des ressources Amazon (arns) et AWS Espacesde noms de service.

Par exemple, pour spécifier le parc fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa dans votredéclaration, utilisez l'ARN suivant :

"Resource": "arn:aws:gamelift:us-west-2:123456789012:fleet/fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa"

Pour spécifier tous les parcs appartenant à un compte spécifique, utilisez le caractère générique (*) :

"Resource": "arn:aws:gamelift:us-west-2:123456789012:fleet/*"

Certaines actions GameLift, telles que la création de ressources, ne peuvent pas être exécutées sur uneressource précise. Dans ce cas, vous devez utiliser le caractère générique (*).

"Resource": "*"

Pour afficher une liste de types de ressource GameLift avec les ARN, veuillez consulter À propos desressources d'hébergement Amazon GameLift (p. 92). Pour en savoir plus sur les actions avec laquelle vouspouvez spécifier l'ARN de chaque ressource, consultez Actions définies par Amazon GameLift.

Clés de conditionAdministrators can use AWS JSON policies to specify who has access to what. That is, which principal canperform actions on what resources, and under what conditions.

L'élément Condition (ou le bloc Condition) vous permet de spécifier des conditions lorsqu’uneinstruction est appliquée. L'élément Condition est facultatif. Vous pouvez créer des expressionsconditionnelles qui utilisent des opérateurs de condition, comme égal ou inférieur, pour faire correspondrela condition de la stratégie aux valeurs de la demande.

Si vous spécifiez plusieurs éléments Condition dans une instruction, ou plusieurs clés dans un seulélément Condition, AWS les évalue à l'aide d'une opération AND logique. Si vous spécifiez plusieursvaleurs pour une seule clé de condition, AWS évalue la condition à l'aide d'une opération OR logique.Toutes les conditions doivent être remplies avant que les autorisations associées à l’instruction ne soientaccordées.

Vous pouvez aussi utiliser des variables d’espace réservé quand vous spécifiez des conditions. Parexemple, vous pouvez accorder à un utilisateur IAM l'autorisation d'accéder à une ressource uniquementsi elle est balisée avec son nom d’utilisateur IAM . Pour de plus amples informations, veuillez consulterÉléments des stratégies IAM : variables et balises dans le IAM Guide de l'utilisateur.

AWS est compatible avec les clés de condition globales et les clés de condition spécifiques à un service.Pour voir toutes les clés de condition globales AWS, veuillez consulter Clés de contexte de conditionglobales AWS dans le IAM Guide de l'utilisateur.

GameLift prend en charge l'utilisation de certaines clés de condition globales. Pour voir tout AWS clés decondition globale, voir AWS Clés contextuelles de conditions générales dans le IAM Guide de l'utilisateur.

Nombreux GameLift les actions soutiennent le aws:RequestedTag clé de condition. Pour afficher uneliste de GameLift clés de condition, voir Clés de condition pour Amazon GameLift dans le IAM Guidede l'utilisateur. Pour savoir avec quelles actions et ressources vous pouvez utiliser une clé de condition,consultez Actions définies par Amazon GameLift.

Examples

Version253

Amazon GameLift Manuel du développeurComment GameLift fonctionne avec IAM

Pour voir des exemples de stratégies GameLift basées sur l'identité, veuillez consulter GameLiftExemplesde stratégies basées sur l'identité (p. 255).

GameLiftStratégies basées sur les ressourcesGameLift ne prend pas en charge les stratégies basées sur les ressource.

Autorisation basée sur GameLift tagsVous pouvez attacher des balises aux ressources de GameLift, ou transmettre des balises dans unerequête à GameLift. Pour contrôler l’accès en fonction des balises, vous fournissez des informations surles balises dans élément de condition d’une politique utilisant gamelift:ResourceTag/key-name,aws:RequestTag/key-name, ou aws:TagKeys de condition. Pour plus d’informations sur l’étiquetageGameLift ressources, voir tagresource() dans le Référence d'API Amazon GameLift.

Pour voir un exemple de stratégie basée sur l'identité permettant de limiter l'accès à une ressource enfonction des balises de celle-ci, consultez Afficher les flottes GameLift en fonction des balises (p. 257).

GameLift IAM rôlesUn IAM rôle est une entité dans votre AWS compte ayant des autorisations spécifiques.

Utilisation d'informations d'identification temporaires avec GameLiftVous pouvez utiliser des informations d'identification temporaires pour vous connecter avec la fédération,assumer un rôle IAM, ou encore pour assumer un rôle entre comptes. Vous obtenez des informationsde sécurité temporaires en appelant AWS STS Les opérations API telles que hypothèse ou jetongetfederationtoken.

GameLift prend en charge l'utilisation des informations d'identification temporaires.

Rôles liés à un serviceRôles liés au service autoriser AWS services pour accéder aux ressources d’autres services afin de réaliserune action en votre nom. Les rôles liés à un service s'affichent dans votre compte IAM et sont détenus parle service. Un administrateur IAM peut consulter, mais ne peut pas modifier les autorisations concernant lesrôles liés à un service.

GameLift ne prend pas en charge les rôles liés à un service

Rôles de serviceCette fonction permet à un service d’assumer rôle de service en votre nom. Ce rôle autorise le service àaccéder à des ressources d'autres services pour effectuer une action en votre nom. Les rôles de services'affichent dans votre compte IAM et sont la propriété du compte. Cela signifie qu'un administrateurIAM peut modifier les autorisations associées à ce rôle. Toutefois, une telle action peut perturber le bonfonctionnement du service.

GameLift prend en charge l'utilisation des rôles de service pour les scénarios suivants :

• Autoriser votre GameLift-des serveurs de jeux hébergés pour accéder à d’autres ressources AWS,comme AWS Lambda ou un Amazon DynamoDB base de données. Parce que les serveurs de jeux sonthébergés sur des flottes gérées par GameLift, vous avez besoin d’un rôle de service qui donne GameLiftaccès limité à vos autres ressources AWS. Pour plus d'informations, consultez Communiquez avecd’autres ressources AWS de vos flottes (p. 49).

• Lorsque vous utilisez GameLift FleetIQ comme solution autonome, permettez GameLift pouréquilibrer votre Amazon EC2 et Auto Scaling ressources hébergeant vos serveurs de jeux. Pour plusd’informations, voir Créer des rôles IAM pour l'interaction entre services (p. 231) dans le GameLiftFleetIQ Guide.

Version254

Amazon GameLift Manuel du développeurExemples de stratégie basée sur l'identité

GameLiftExemples de stratégies basées sur l'identitéPar défaut, IAM les utilisateurs et les rôles n’ont pas l’autorisation de créer ou de modifier GameLiftressources. Ils ne peuvent pas effectuer des tâches à l’aide du AWS Management Console, AWS CLI, ouAWS API. Un IAM l’administrateur doit créer IAM les politiques qui accordent aux utilisateurs et aux rôlesl’autorisation d’effectuer des opérations API spécifiques sur les ressources spécifiées dont ils ont besoin. Ildoit ensuite attacher ces stratégies aux utilisateurs ou aux groupes IAM ayant besoin de ces autorisations.

Apprendre à créer un IAM politique basée sur l’identité utilisant ces documents de politique JSON, voirCréation de politiques sur l’onglet JSON dans le IAM Guide de l'utilisateur.

Rubriques• Bonnes pratiques en matière de stratégies (p. 255)• avec la GameLift console. (p. 255)• Autorisation accordée aux utilisateurs pour afficher leurs propres autorisations (p. 256)• Autoriser l'accès de joueurs pour les sessions de jeu (p. 256)• Autoriser l’accès à un GameLift file d’ (p. 257)• Afficher les flottes GameLift en fonction des balises (p. 257)

Bonnes pratiques en matière de stratégiesLes stratégies basées sur l'identité sont très puissantes. Elles déterminent si une personne peut créer,consulter ou supprimer des ressources GameLift dans votre compte. Ces actions peuvent entraîner desfrais pour votre compte AWS. Lorsque vous créez ou modifiez des stratégies basées sur l'identité, suivezces instructions et recommandations :

• Commencer à utiliser les stratégies gérées AWS – Pour commencer à utiliser GameLift rapidement,utilisez les stratégies gérées AWS pour accorder à vos employés les autorisations dont ils ont besoin.Ces stratégies sont déjà disponibles dans votre compte et sont gérées et mises à jour par AWS. Pourplus d'informations, consultez la section Mise en route avec les autorisations à l'aide des stratégiesgérées AWS dans le IAM Guide de l'utilisateur.

• Accorder l'accès avec le moindre privilège – Lorsque vous créez des stratégies personnalisées,accordez uniquement les autorisations requises pour exécuter une seule tâche. Commencez avec unminimum d'autorisations et accordez-en d'autres si nécessaire. Cette méthode est plus sûre que decommencer avec des autorisations trop permissives et d'essayer de les restreindre plus tard. Pourplus d'informations, consultez Accorder les privilèges les plus faibles possible dans le IAM Guide del'utilisateur.

• Activer MFA pour les opérations sensibles – Pour plus de sécurité, obligez les utilisateurs IAM àutiliser l'authentification multi-facteurs (MFA) pour accéder à des ressources ou à des opérations d'APIsensibles. Pour plus d'informations, consultez Utilisation de Multi-Factor Authentication (MFA) dans AWSdans le IAM Guide de l'utilisateur.

• Utiliser des conditions de stratégie pour une plus grande sécurité – Tant que cela reste pratique pourvous, définissez les conditions dans lesquelles vos stratégies basées sur l'identité autorisent l'accès àune ressource. Par exemple, vous pouvez rédiger les conditions pour spécifier une plage d'adresses IPautorisées d'où peut provenir une demande. Vous pouvez également écrire des conditions pour autoriserles requêtes uniquement à une date ou dans une plage de temps spécifiée, ou pour imposer l'utilisationde SSL ou de MFA. Pour de plus amples informations, veuillez consulter Éléments de stratégie JSONIAM : condition dans le IAM Guide de l'utilisateur.

avec la GameLift console.Pour accéder à la console GameLift, vous devez détenir un ensemble minimum d'autorisations. Cesautorisations doivent vous permettre de répertorier et d’afficher les détails sur GameLift ressources dans

Version255

Amazon GameLift Manuel du développeurExemples de stratégie basée sur l'identité

votre AWS compte. Si vous créez une stratégie basée sur l'identité qui est plus restrictive que l'ensembleminimum d'autorisations requis, la console ne fonctionnera pas comme prévu pour les entités (utilisateurset rôles IAM) tributaires de cette stratégie.

Pour vous assurer que ces entités peuvent toujours utiliser la console GameLift, ajoutez une stratégie enligne aux utilisateurs et aux groupes avec la syntaxe de stratégie suivante. Pour plus d’informations, voirAjout d’autorisations à un utilisateur dans le IAM Guide de l'utilisateur. Vous n’avez pas besoin de laisserles autorisations de console minimales pour les utilisateurs qui effectuent des appels uniquement versle AWS CLI ou le AWS API, telles que les joueurs utilisant des clients de jeux. Autorisez plutôt l'accès àuniquement aux actions qui correspondent à l'opération d'API que vous tentez d'effectuer.

• Autorisations requises pour utiliser toutes les fonctionnalités de la console GameLift : veuillez consulterla syntaxe de stratégie en ligne pour les administrateurs dans Exemples de stratégies IAM pourGameLift (p. 24).

Autorisation accordée aux utilisateurs pour afficher leurs propresautorisationsCet exemple montre comment créer une stratégie qui permet aux utilisateurs IAM d'afficher les stratégiesen ligne et gérées attachées à leur identité d'utilisateur. Cette stratégie inclut les autorisations nécessairespour réaliser cette action sur la console ou par programmation à l'aide de l’AWS CLI ou de l'API AWS.

{ "Version": "2012-10-17", "Statement": [ { "Sid": "ViewOwnUserInfo", "Effect": "Allow", "Action": [ "iam:GetUserPolicy", "iam:ListGroupsForUser", "iam:ListAttachedUserPolicies", "iam:ListUserPolicies", "iam:GetUser" ], "Resource": ["arn:aws:iam::*:user/${aws:username}"] }, { "Sid": "NavigateInConsole", "Effect": "Allow", "Action": [ "iam:GetGroupPolicy", "iam:GetPolicyVersion", "iam:GetPolicy", "iam:ListAttachedGroupPolicies", "iam:ListGroupPolicies", "iam:ListPolicyVersions", "iam:ListPolicies", "iam:ListUsers" ], "Resource": "*" } ]}

Autoriser l'accès de joueurs pour les sessions de jeuVous souhaitez accorder l'accès nécessaire aux clients de jeu (ou aux services clients qui gèrent lesdemandes des clients de jeu) pour créer de nouvelles sessions de jeu et demander le placement du joueur

Version256

Amazon GameLift Manuel du développeurExemples de stratégie basée sur l'identité

dans une session de jeu disponible. Il existe plusieurs façons pour votre jeu d'accomplir cette tâche,notamment en utilisant les placements de session de jeu avec des files d'attente, de la mise en relation oudu placement manuel. Pour afficher des exemples de stratégie pour ces scénarios, veuillez consulter lasyntaxe de stratégie en ligne pour les joueurs dans Exemples de stratégies IAM pour GameLift (p. 24).

Autoriser l’accès à un GameLift file d’Dans cet exemple, vous souhaitez accorder une IAM utilisateur dans votre AWS accès à l’un de vosGameLift files d’attente, gamesessionqueue/examplequeue123, y compris la possibilité d’ajouter, demettre à jour et de supprimer des destinations de file d’attente.

Cette politique accorde des autorisations à l’utilisateur pour les actions suivantes :gamelift:UpdateGameSessionQueue, gamelift:DeleteGameSessionQueue, etgamelift:DescribeGameSessionQueues. Comme indiqué, cette politique utilise l’élément deressource pour limiter l’accès à une seule file d’attente.

{ "Version":"2012-10-17", "Statement":[ { "Sid":"ViewSpecificQueueInfo", "Effect":"Allow", "Action":[ "gamelift:DescribeGameSessionQueues" ], "Resource":"arn:aws:gamelift:::gamesessionqueue/examplequeue123" }, { "Sid":"ManageSpecificQueue", "Effect":"Allow", "Action":[ "gamelift:UpdateGameSessionQueue", "gamelift:DeleteGameSessionQueue" ], "Resource":"arn:aws:gamelift:::gamesessionqueue/examplequeue123" } ]}

Afficher les flottes GameLift en fonction des balisesVous pouvez utiliser des conditions dans votre stratégie basée sur l’identité pour contrôler l'accès auxressources GameLift en fonction des balises. Cet exemple montre comment créer une stratégie quiautorise l'affichage d'un parc. Toutefois, l'autorisation est accordée uniquement si la balise de parc Ownera pour valeur le nom d'utilisateur de cet utilisateur. Cette stratégie accorde également les autorisationsnécessaires pour réaliser cette action sur la console.

{ "Version": "2012-10-17", "Statement": [ { "Sid": "ListFleetsInConsole", "Effect": "Allow", "Action": "gamelift:ListFleets", "Resource": "*" }, { "Sid": "ViewFleetIfOwner", "Effect": "Allow", "Action": "gamelift:DescribeFleetAttributes",

Version257

Amazon GameLift Manuel du développeurDépannage

"Resource": "arn:aws:gamelift:*:*:fleet/*", "Condition": { "StringEquals": {"gamelift:ResourceTag/Owner": "${aws:username}"} } } ]}

Vous pouvez attacher cette stratégie aux utilisateurs IAM de votre compte. Si un utilisateur nommérichard-roe tente de voir GameLift flotte, la flotte doit être étiquetée Owner=richard-roe ouowner=richard-roe. Sinon, il est refusé d’accéder à. La clé d’étiquette de condition Owner correspondà tous les deux Owner et owner parce que les noms de clés de condition ne sont pas sensibles à lacasse. Pour plus d’informations, voir IAM Éléments de la politique JSON : Condition dans le IAM Guide del'utilisateur.

Dépannage GameLift identité et accèsUtilisez les informations suivantes pour identifier et résoudre les problèmes courants que vous pouvezrencontrer lorsque vous travaillez avec GameLift et ()IAM.

Rubriques• Je ne suis pas autorisé à exécuter une action dans GameLift (p. 258)• Je ne suis pas autorisé à exécuter : iam:PassRole (p. 258)• Je veux afficher mes clés d'accès (p. 259)• Je suis un administrateur et je souhaite autoriser d'autres utilisateurs à accéder à GameLift (p. 259)• Je veux permettre aux gens en dehors de mon AWS pour accéder à mon GameLift

ressources (p. 259)

Je ne suis pas autorisé à exécuter une action dans GameLiftSi AWS Management Console indique que vous n'êtes pas autorisé à exécuter une action, vous devezcontacter votre administrateur pour obtenir de l'aide. Votre administrateur est la personne qui vous a fournivotre nom d'utilisateur et votre mot de passe.

L’erreur d’exemple suivante se produit lorsque le mateojackson IAM l’utilisateur tente d’utiliser la consolepour afficher les détails d’une file d’attente mais n’a pas gamelift:DescribeGameSessionQueuesautorisations.

User: arn:aws:iam::123456789012:user/mateojackson is not authorized to perform: gamelift:DescribeGameSessionQueues on resource: examplequeue123

Dans ce cas, Mateo demande à son administrateur de mettre à jour ses politiques pour lui permettred’accéder au examplequeue123 ressource utilisant le gamelift:DescribeGameSessionQueues.

Je ne suis pas autorisé à exécuter : iam:PassRoleSi vous recevez un message d'erreur selon lequel vous n'êtes pas autorisé à exécuter l'actioniam:PassRole, vous devez contacter votre administrateur pour obtenir de l'aide. Votre administrateur estla personne qui vous a fourni votre nom d'utilisateur et votre mot de passe. Demandez à cette personne demettre à jour vos stratégies pour vous permettre de transmettre un rôle à GameLift.

Certains services AWS vous permettent de transmettre un rôle existant à ce service, au lieu de créer unnouveau rôle de service ou rôle lié à un service. Pour ce faire, un utilisateur doit disposer des autorisationsnécessaires pour transmettre le rôle au service.

Version258

Amazon GameLift Manuel du développeurDépannage

L'exemple d'erreur suivant se produit lorsqu'un utilisateur IAM nommé marymajor essaie d'utiliser laconsole pour exécuter une action dans GameLift. Toutefois, l'action nécessite que le service ait desautorisations accordées par un rôle de service. Mary ne dispose pas des autorisations nécessaires pourtransférer le rôle au service.

User: arn:aws:iam::123456789012:user/marymajor is not authorized to perform: iam:PassRole

Dans ce cas, Mary demande à son administrateur de mettre à jour ses stratégies pour lui permettred'exécuter l'action iam:PassRole.

Je veux afficher mes clés d'accèsUne fois que vous avez créé vos clés d'accès IAM, vous pouvez afficher votre ID de clé d'accès à toutmoment. Toutefois, vous ne pouvez pas afficher à nouveau votre clé d'accès secrète. Si vous perdez votreclé d'accès secrète, vous devez créer une nouvelle paire de clés.

Les clés d'accès se composent de deux parties : un ID de clé d'accès (par exemple,AKIAIOSFODNN7EXAMPLE) et une clé d'accès secrète (par exemple, wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY). À l'instar d'un nom d'utilisateur et un mot de passe, vous devez utiliser à la foisl'ID de clé d'accès et la clé d'accès secrète pour authentifier vos demandes. Gérez vos clés d'accès demanière aussi sécurisée que votre nom d'utilisateur et votre mot de passe.

Important

Ne communiquez pas vos clés d'accès à un tiers, même pour qu'il vous aide à trouver votre IDutilisateur canonique. En effet, vous lui accorderiez ainsi un accès permanent à votre compte.

Lorsque vous créez une paire de clé d'accès, enregistrez l'ID de clé d'accès et la clé d'accès secrète dansun emplacement sécurisé. La clé d'accès secrète est accessible uniquement au moment de sa création. Sivous perdez votre clé d'accès secrète, vous devez ajouter de nouvelles clés d'accès pour votre utilisateurIAM. Vous pouvez avoir un maximum de deux clés d'accès. Si vous en avez déjà deux, vous devezsupprimer une paire de clés avant d'en créer une nouvelle. Pour obtenir plus d'informations, consultezGestion des clés d'accès dans le IAM Guide de l'utilisateur.

Je suis un administrateur et je souhaite autoriser d'autresutilisateurs à accéder à GameLiftPour permettre à d'autres utilisateurs d'accéder à GameLift vous devez créer une entité IAM (utilisateur ourôle) pour la personne ou l'application qui a besoin de l'accès. Ils utiliseront les informations d'identificationde cette entité pour accéder à AWS. Vous devez ensuite associer une stratégie à l'entité qui leur accordeles autorisations appropriées dans GameLift.

Pour démarrer immédiatement, consultez Création de votre premier groupe et utilisateur délégué IAM dansle IAM Guide de l'utilisateur.

Je veux permettre aux gens en dehors de mon AWS pouraccéder à mon GameLift ressourcesVous pouvez créer un rôle que les utilisateurs provenant d'autres comptes ou les personnes extérieures àvotre organisation peuvent utiliser pour accéder à vos ressources. Vous pouvez spécifier qui est approuvépour assumer le rôle. Pour les services qui prennent en charge les stratégies basées sur les ressourcesou les listes de contrôle d'accès (ACL), vous pouvez utiliser ces stratégies pour accorder aux personnesl'accès à vos ressources.

Pour en savoir plus, consultez les éléments suivants :

Version259

Amazon GameLift Manuel du développeurJournalisation et surveillance avec GameLift

• Pour savoir si GameLift prend en charge ces fonctionnalités, consultez Comment GameLift fonctionneavec IAM (p. 251).

• Pour savoir comment fournir un accès à vos ressources sur les comptes AWS que vous détenez,consultez Octroi à un utilisateur IAM de l'autorisation d'accès à un autre compte AWS vous appartenantdans le IAM Guide de l'utilisateur.

• Pour savoir comment fournir l'accès à vos ressources à des comptes AWS tiers, veuillez consulter Octroid'un accès à des comptes AWS appartenant à des tiers dans le IAM Guide de l'utilisateur.

• Pour savoir comment fournir un accès par le biais de la fédération d'identité, consultez Octroi d'accès àdes utilisateurs authentifiés en externe (fédération d'identité) dans le IAM Guide de l'utilisateur.

• Pour en savoir plus sur la différence entre l'utilisation des rôles et des stratégies basées sur lesressources pour l'accès entre comptes, consultez Différence entre les rôles IAM et les stratégies baséessur les ressources dans le IAM Guide de l'utilisateur.

Journalisation et surveillance avec GameLiftLa surveillance est un enjeu important pour assurer la fiabilité, la disponibilité et les performances deGameLift et de vos solutions AWS. Vous devez recueillir les données de surveillance de toutes les partiesde votre solution AWS de telle sorte que vous puissiez déboguer plus facilement une éventuelle défaillanceà plusieurs points.

AWS et GameLift fournissent plusieurs outils pour surveiller vos ressources d'hébergement de jeux etrépondre aux incidents potentiels.

Alarmes Amazon CloudWatch

Les alarmes Amazon CloudWatch permettent de surveiller une métrique unique sur une période de tempsque vous spécifiez. Si la métrique dépasse un seuil donné, une notification est envoyée à une rubriqueAmazon SNS ou à une stratégie AWS Auto Scaling. Les alarmes CloudWatch sont déclenchées lorsqueleur état change et sont conservées pendant un nombre de périodes spécifié, et non en fonction d'un étatparticulier. Pour plus d'informations, consultez Surveiller GameLift avec Amazon CloudWatch (p. 202).

Journaux AWS CloudTrail

CloudTrail fournit un enregistrement des actions réalisées par un utilisateur, un rôle ou un service AWSdans GameLift. Avec les informations collectées par CloudTrail, vous pouvez déterminer la demande qui aété envoyée à GameLift, l'adresse IP à partir de laquelle la demande a été effectuée, l'auteur et la date dela demande, ainsi que d'autres détails. Pour plus d'informations, consultez Journalisation des appels d'APIAmazon GameLift avec AWS CloudTrail (p. 215).

Validation de la conformité pour GameLiftGameLift n'entre pas dans le champ d'application des programmes de conformité AWS.

Pour obtenir la liste des services AWS relevant de programmes de conformité spécifiques, consultezServices AWS relevant de programmes de conformité. Pour obtenir des renseignements généraux,consultez Programmes de conformitéAWS .

Vous pouvez télécharger les rapports de l'audit externe avec AWS Artifact. Pour plus d'informations,consultez Téléchargement de rapports dans AWS Artifact.

Votre responsabilité en matière de conformité lorsque vous utilisez des services AWS est déterminée parla sensibilité de vos données, des objectifs de conformité de votre entreprise, ainsi que de la législation

Version260

Amazon GameLift Manuel du développeurRésilience

et de la réglementation en vigueur. AWS fournit les ressources suivantes pour faciliter le respect de laconformité :

• Guides de démarrage rapide de la sécurité et de la conformité – Ces guides de déploiement proposentdes considérations architecturales et fournissent des étapes pour déployer des environnements deréférence centrés sur la sécurité et la conformité sur AWS.

• Livre blanc sur l'architecture pour la sécurité et la conformité HIPAA – Le livre blanc décrit comment lesentreprises peuvent utiliser AWS pour créer des applications conformes à la loi HIPAA.

Note

Tous les services ne sont pas conformes à HIPAA.• Ressources de conformité AWS – Cet ensemble de manuels et de guides peut s'appliquer à votre

secteur et à votre emplacement.• Évaluation des ressources à l'aide de règles dans le Guide du développeur AWS Config – Le service

AWS Config évalue dans quelle mesure vos configurations de ressources sont conformes aux pratiquesinternes, aux directives sectorielles et aux réglementations.

• AWS Security Hub – Ce service AWS fournit une vue complète de votre état de sécurité au sein d'AWSqui vous permet de vérifier votre conformité aux normes du secteur et aux bonnes pratiques de sécurité.

Résilience dans GameLiftSi vous utilisez GameLift FleetIQ comme fonction autonome avec Amazon EC2, veuillez égalementconsulter Sécurité dans Amazon EC2 dans le Amazon EC2 Guide de l'utilisateur pour les instances Linux.

L'infrastructure mondiale dAWS repose sur des régions et des zones de disponibilité AWS. Les régionsAWS fournissent plusieurs zones de disponibilité physiquement séparées et isolées, reliées par un réseauà latence faible, à débit élevé et à forte redondance. Avec les zones de disponibilité, vous pouvez concevoiret exploiter des applications et des bases de données qui basculent automatiquement d'une zone à l'autresans interruption. Les zones de disponibilité sont plus hautement disponibles, tolérantes aux pannes etévolutives que les infrastructures traditionnelles à un ou plusieurs centres de données.

Pour plus d'informations sur les régions et les zones de disponibilité AWS, consultez Infrastructuremondiale AWS.

Outre l'infrastructure globale AWS, GameLift propose plusieurs fonctionnalités qui contribuent à la prise encharge de vos besoins en matière de résilience de données :

• Files d'attente multi-région : les files d'attente multi-région GameLift sont utilisées pour placer denouvelles sessions de jeu avec des ressources d'hébergement disponibles. Les files d'attente couvrantplusieurs régions peuvent rediriger les placements de session de jeu en cas de panne au niveau d'unerégion. Pour de plus amples informations et connaître les bonnes pratiques relatives à la création de filesd'attente de session de jeu, veuillez consulter Conception d'une file d'attente de session de jeu (p. 143).

• Dimensionnement automatique des capacités : maintenez l'intégrité et la disponibilité de vos ressourcesd'hébergement à l'aide des outils de dimensionnement GameLift. Ces outils offrent une palette d'optionsqui vous permettent d'ajuster la capacité de votre parc en fonction des besoins de votre jeu et desjoueurs. Pour de plus amples informations sur le dimensionnement, veuillez consulter Dimensionnementde la capacité d'une flotte GameLift (p. 133).

• Répartition entre les instances : GameLift répartit le trafic entrant entre plusieurs instances, en fonctionde la taille du parc. Pour les jeux en production, une bonne pratique consiste à disposer de plusieursinstances pour conserver la disponibilité au cas où une instance devient non saine ou ne répond pas.

• Stockage Amazon S3 : les builds et les scripts de serveur de jeu qui sont chargés sur GameLift sontstockés dans Amazon S3 avec la classe de stockage Standard, qui utilise plusieurs réplications de centrede données pour augmenter la résilience. Les journaux de session de jeu sont également stockés dansAmazon S3 avec la classe de stockage Standard.

Version261

Amazon GameLift Manuel du développeurSécurité de l'infrastructure

Sécurité de l'infrastructure dans GameLiftSi vous utilisez GameLift FleetIQ comme fonction autonome avec Amazon EC2, veuillez égalementconsulter Sécurité dans Amazon EC2 dans le Amazon EC2 Guide de l'utilisateur pour les instances Linux.

En tant que service géré, GameLift est protégé par les procédures de sécurité du réseau mondial AWS quisont décrites dans le livre blanc Amazon Web Services : Présentation des procédures de sécurité.

Vous utilisez les appels d'API publiés AWS pour accéder à GameLift via le réseau. Les clientsdoivent prendre en charge le protocole TLS (Transport Layer Security) 1.0 ou version ultérieure. Nousrecommandons TLS 1.2 ou version ultérieure. Les clients doivent également prendre en charge les suitesde chiffrement PFS (Perfect Forward Secrecy) comme Ephemeral Diffie-Hellman (DHE) ou Elliptic CurveEphemeral Diffie-Hellman (ECDHE) La plupart des systèmes modernes telles que Java 7 et versionsultérieures prennent en charge ces modes.

En outre, les demandes doivent être signées à l'aide d'un ID de clé d'accès et d'une clé d'accès secrèteassociée à un mandataire IAM. Vous pouvez également utiliser AWS Security Token Service (AWS STS)pour générer des informations d'identification de sécurité temporaires et signer les demandes.

Le service GameLift place tous les parcs dans des clouds privés virtuels (VPC) Amazon de sorte quechaque parc existe dans une zone du cloud AWS isolée logiquement. Vous pouvez utiliser des stratégiesGameLift pour contrôler l'accès depuis des points de terminaison de VPC spécifiques ou des VPCspécifiques. En effet, cela permet d'isoler l'accès réseau vers une ressource GameLift donnée depuis leVPC spécifique uniquement au sein du réseau AWS. Lorsque vous créez un parc, vous spécifiez uneplage de numéros de port et d'adresses IP. Ces plages limitent la façon dont le trafic entrant peut accéderaux serveurs de jeux hébergés sur un VPC de parc. Utilisez les bonnes pratiques en matière de sécuritéstandard lorsque vous choisissez les paramètres d'accès au parc.

Configuration et analyse des vulnérabilités dansGameLift

Si vous utilisez GameLift FleetIQ comme fonction autonome avec Amazon EC2, veuillez égalementconsulter Sécurité dans Amazon EC2 dans le Amazon EC2 Guide de l'utilisateur pour les instances Linux.

La configuration et les contrôles informatiques sont une responsabilité partagée entre AWS et vous, notreclient. Pour de plus amples informations, veuillez consulter AWS Modèle de responsabilité partagée.AWS gère les tâches de sécurité de base comme les correctifs du système d'exploitation invité et de basede données, la configuration du pare-feu, et la reprise après sinistre. Ces procédures ont été vérifiéeset certifiées par les tiers appropriés. Pour plus de détails, consultez la ressource suivante : AmazonWeb Services: Overview of Security Processes (Amazon Web Services : Présentation des processus desécurité) (livre blanc).

Les bonnes pratiques de sécurité suivantes s'appliquent également à la configuration et à l'analyse desvulnérabilités dans GameLift :

• Les clients sont responsables de la gestion des logiciels déployés sur les instances GameLift pourl'hébergement de jeux. En particulier :• Les logiciels d'application de serveur de jeux fournis par le client doivent être gérés, y compris les

mises à jour et les correctifs de sécurité. Pour mettre à jour un logiciel de serveur de jeux, chargez unenouvelle build dans GameLift, créez un nouveau parc pour celle-ci et redirigez le trafic vers le nouveauparc.

• L'AMI (Amazon Machine Image) de base, qui inclut le système d'exploitation, est mise à jouruniquement lorsqu'un nouveau parc est créé. Pour appliquer des correctifs, mettre à jour et sécuriser

Version262

Amazon GameLift Manuel du développeurBonnes pratiques de sécurité

le système d'exploitation et les autres applications faisant partie de l'AMI, recyclez régulièrement lesparcs, indépendamment des mises à jour du serveur de jeu.

• Les clients doivent envisager de mettre régulièrement à jour leurs jeux avec les dernières versions dekit SDK, y compris le kit SDK AWS, le kit SDK GameLift Server et le kit SDK GameLift Client pour lesserveurs en temps réel.

Bonnes pratiques de sécurité pour AmazonGameLift

Si vous utilisez GameLift FleetIQ comme fonction autonome avec Amazon EC2, veuillez égalementconsulter Sécurité dans Amazon EC2 dans le Amazon EC2 Guide de l'utilisateur pour les instances Linux.

GameLift fournit différentes fonctions de sécurité à prendre en compte lorsque vous développez etimplémentez vos propres stratégies de sécurité. Les bonnes pratiques suivantes doivent être considéréescomme des instructions générales et ne représentent pas une solution de sécurité complète. Étant donnéque ces bonnes pratiques peuvent ne pas être appropriées ou suffisantes pour votre environnement,considérez-les comme des remarques utiles plutôt que comme des recommandations.

• Amazon Web Services : Présentation des procédures de sécurité (livre blanc)• AWS Security Best Practices (Bonnes pratiques de sécurité AWS) (livre blanc)

Version263

Amazon GameLift Manuel du développeurRéférence d'API de service (kit SDK AWS)

Guides de référence AmazonGameLift

Cette section contient la documentation de référence pour utiliser Amazon GameLift.

Rubriques• Référence API de service GameLift (kit SDK AWS) (p. 264)• Référence Amazon GameLift Serveurs en temps réel (p. 269)• Référence SDK Server Amazon GameLift (p. 286)• Référence GameLift FlexMatch (p. 324)

Référence API de service GameLift (kit SDK AWS)L'API de service GameLift est intégrée au kit SDK AWS. Téléchargez le kit AWS SDK ou consultez ladocumentation de référence des API Amazon GameLift.

• API pour GameLift géré

Ces opérations font partie de la solution GameLift entièrement gérée pour les serveurs de jeuxpersonnalisés et les serveurs en temps réel.• Utilisation des sessions de jeu et des joueurs (p. 264)• Utilisation des ressources d'hébergement GameLift gérées (p. 265)• Utilisation de la mise en relation FlexMatch (p. 268)

• API pour GameLift FleetIQ

Ces opérations sont destinées à la solution autonome FleetIQ pour une utilisation avec l'hébergement dejeux sur Amazon EC2.• Utilisation des GameLift FleetIQ (p. 268)

• Langages de programmation disponibles (p. 269)

Utilisation des sessions de jeu et des joueursLorsque vous utilisez une solution GameLiftgérée, appelez ces opérations à partir de votre service clientde jeu pour démarrer ou rejoindre des sessions de jeu et accéder aux données de session de jeu et dejoueur. Ces opérations sont pour les jeux avec des serveurs de jeux personnalisés qui sont hébergés surGameLift. Si vous utilisez Serveurs en temps réel, consultez le Référence d'API de client Serveurs entemps réel (C#) (p. 270).

• Démarrage de nouvelles sessions de jeu pour un ou plusieurs joueurs. Trouvez les meilleuresressources d'hébergement actuellement disponibles et utilisez-les pour démarrer une nouvelle sessionde jeu. Vous pouvez également créer une nouvelle session de jeu sur une flotte spécifique.• StartGameSessionPlacement – Demander un nouveau placement de session de jeu et y ajouter un ou

plusieurs joueurs.• DescribeGameSessionPlacement – Obtenir des détails sur une demande de placement.• StopGameSessionPlacement – Annuler une demande de placement.

Version264

Amazon GameLift Manuel du développeurUtilisation des ressources d'hébergement

• CreateGameSession – Démarrer une nouvelle session de jeu sur une flotte spécifique. disponibledans GameLift Local.

• Insertion de joueurs dans des jeux existants. Recherchez des jeux existants avec des emplacements dejoueur disponibles et réservez-les pour de nouveaux joueurs.• SearchGameSessions – Récupérer toutes les sessions de jeu disponibles ou rechercher des sessions

de jeu qui correspondent à un ensemble de critères.• CreatePlayerSession – Réserver un emplacement ouvert pour qu'un joueur rejoigne une session de

jeu. disponible dans GameLift Local.• CreatePlayerSessions – Réserver des emplacements ouverts pour que plusieurs joueurs rejoignent

une session de jeu. disponible dans GameLift Local.• Utilisation avec des données de session de jeu et de session de joueur. Récupérez les données

actuelles sur les sessions de jeu et les sessions de joueur existantes, et procédez à une mise à jour enfonction des besoins.• DescribeGameSessions – Récupérer les métadonnées d'une ou plusieurs sessions de jeu, y compris

la durée active et le nombre de joueurs actuels. disponible dans GameLift Local.• DescribeGameSessionDetails – Récupérer les métadonnées et le paramètre de protection de session

de jeu pour une ou plusieurs sessions de jeu.• GetGameSessionLogUrl – Obtenir l'emplacement des journaux enregistrés pour une session de jeu.• DescribePlayerSessions – Obtenir des détails sur l'activité des joueurs, y compris le statut, le temps de

lecture et les données des joueurs. disponible dans GameLift Local.• UpdateGameSession – Modifier les paramètres de session de jeu, tels que le nombre maximal de

joueurs et la stratégie de participation.

Utilisation des ressources d'hébergement GameLiftgéréesLorsque vous utilisez une solution GameLift gérée, appelez ces opérations pour configurer des ressourcesd'hébergement pour vos serveurs de jeux, augmenter la capacité pour répondre à la demande des joueurs,accéder aux métriques de performance et d'utilisation, etc. Ces opérations d'API sont utilisées avec desserveurs de jeux qui sont hébergés sur GameLift, y compris Serveurs en temps réel. Vous pouvez utiliserConsole GameLift pour la plupart des tâches de gestion des ressources ou effectuer des appels au serviceà l'aide de l'outil AWS Command Line Interface (AWS CLI) ou du kit AWS SDK.

Configurer les serveurs de jeuxConfigurez les serveurs de jeu pour votre jeu, qui sont déployés dans des flottes pour l'hébergement.

Builds de serveurs de jeux personnalisés

• CreateBuild – Créer une nouvelle build à l'aide de fichiers stockés dans un compartiment Amazon S3.Pour créer une build et charger des fichiers à partir d'un chemin d'accès local, utilisez la commanded’AWS CLI upload-build.

• ListBuilds– Obtenir une liste de toutes les builds chargées dans une région GameLift.• DescribeBuild – Récupérer les informations associées à une build.• UpdateBuild – Modifier les métadonnées de build, y compris le nom et la version de build.• DeleteBuild – Supprimer une build d’GameLift.

Serveurs en temps réel scripts de configuration

• CreateScript – Créer un script de serveur à exécuter sur Serveurs en temps réel.• Scripts de liste – Obtenir une liste de tous RealTime les scripts chargés sur un GameLift région.

Version265

Amazon GameLift Manuel du développeurUtilisation des ressources d'hébergement

• DescribeScript – Récupérer les informations associées à un script RealTime.• UpdateScript – Modifier les métadonnées du script et charger le contenu révisé du script.• DeleteScript – Supprimer un script RealTime d’GameLift.

Gérer les ressources informatiquesConfigurez les ressources d'hébergement et déployez votre build de serveur de jeux ou votre script deconfiguration RealTime.

Flottes

• CreateFleet – Configurer et activer une nouvelle flotte pour exécuter votre build de serveur de jeuxpersonnalisé ou votre script RealTime.

• ListFleets – Obtenir la liste de toutes les flottes d'une région GameLift.• DeleteFleet – Mettre fin à une flotte qui n'exécute plus de serveurs de jeux ou n'héberge plus de joueurs.• Afficher/mettre à jour les configurations de flotte.

• DescribeFleetAttributes / UpdateFleetAttributes – Afficher ou modifier les métadonnées et lesparamètres d'une flotte pour la protection d’une session de jeu et les limites de création de ressources.

• DescribeFleetPortSettings / UpdateFleetPortSettings – Afficher ou modifier les autorisations entrantes(plages d'adresse IP et de port) pour une flotte.

• DescribeRuntimeConfiguration / UpdateRuntimeConfiguration– Afficher ou modifier les processusserveur (et leur nombre) à exécuter sur chaque instance d'une flotte.

• Définissez la capacité de la flotte.• DescribeEC2InstanceLimits – Récupérer le nombre maximal d'instances autorisées pour le compte

AWS actuel et le niveau d'utilisation actuel.• DescribeFleetCapacity – Récupérer les paramètres de capacité actuels des flottes• UpdateFleetCapacity – Ajuster manuellement les paramètres de capacité de flotte.• Gérer le dimensionnement automatique :

• PutScalingPolicy – Activer le dimensionnement automatique basé sur la cible, créer une stratégie dedimensionnement automatique personnalisé ou mettre à jour une stratégie existante.

• DescribeScalingPolicies – Récupérer une stratégie de dimensionnement automatique existante.• DeleteScalingPolicy – Supprimer une stratégie de dimensionnement automatique de sorte qu’elle

n’affecte pas la capacité d'une flotte.• StartFleetActions – Redémarrer les stratégies de dimensionnement automatique d'une flotte.• StopFleetActions – Suspendre les stratégies de dimensionnement automatique d'une flotte.

• Surveillance de l'activité de la flotte. Obtenez des informations à jour sur le processus serveur et l'activitéde session de jeu sur une flotte.• DescribeFleetUtilization – Récupérer les statistiques sur le nombre de processus serveur, de sessions

de jeu et de joueurs actuellement actifs sur une flotte.• DescribeFleetEvents – Afficher les événements enregistrés pour une flotte au cours d'une période

spécifiée.• DescribeGameSessions – Récupérer les métadonnées de session de jeu, y compris la durée

d'exécution d'un jeu et le nombre de joueurs actuels.

Configurer les files d'attente pour un placement optimal dessessions de jeuConfigurez des files d'attente sur plusieurs flottes et plusieurs régions pour placer des sessions de jeu avecles meilleures ressources d'hébergement disponibles en matière de coût, de latence et de résilience.

Version266

Amazon GameLift Manuel du développeurUtilisation des ressources d'hébergement

File d'attente des sessions de jeu

• CreateGameSessionQueue – Créer une file d'attente à utiliser lors du traitement des demandes deplacement de session de jeu.

• DescribeGameSessionQueues – Récupérer les files d'attente de session de jeu définies dans une régionGameLift.

• UpdateGameSessionQueue – Modifier la configuration d'une file d'attente de session de jeu.• DeleteGameSessionQueue – Supprimer une file d'attente de session de jeu de la région.

Gérer les alias de flotteUtilisez des alias pour représenter vos flottes ou créer une destination alternative de terminal. Les aliassont utiles lors de la transition de l'activité du jeu d'une flotte à une autre, par exemple lors des mises à jourdes builds du serveur de jeu.

Alias

• CreateAlias – Définir un nouvel alias et, si vous le souhaitez, l’attribuer à une flotte.• ListAliases – Obtenir tous les alias de flotte définis dans une région GameLift.• DescribeAlias – Récupérer des informations sur un alias existant.• UpdateAlias – Modifier les paramètres d'un alias, par exemple en le redirigeant d'une flotte vers une

autre.• DeleteAlias – Supprimer un alias de la région.• ResolveAlias :– Obtenir l'ID de la flotte vers laquelle pointe un alias spécifié.

Accéder aux instances d'hébergementAffichez des informations sur les instances individuelles d'une flotte ou demandez un accès à distance àune instance de flotte spécifiée pour le dépannage.

• DescribeInstances – Récupérer des informations sur chaque instance d'une flotte, y compris l'IDd'instance, l'adresse IP et l'état.

• GetInstanceAccess – Demander les informations d'identification d'accès nécessaires pour vousconnecter à distance à une instance spécifiée dans une flotte.

Configurer l'appairage de VPCCréez et gérez des connexions d'appairage VPC entre vos ressources d'hébergement GameLift et lesautres ressources AWS.

• CreateVpcPeeringAuthorization – Autoriser une connexion d'appairage à un de vos VPC.• DescribeVpcPeeringAuthorizations – Récupérer les autorisations de connexion d'appairage valides.• DeleteVpcPeeringAuthorization – Supprimer une autorisation de connexion d'appairage.• CreateVpcPeeringConnection – Établir une connexion d'appairage entre le VPC d'une flotte GameLift et

un de vos VPC.• DescribeVpcPeeringConnections – Récupérer des informations sur les connexions d'appairage de VPC

actives ou en attente avec une flotte GameLift.• DeleteVpcPeeringConnection – Supprimer une connexion d'appairage de VPC avec une flotte GameLift.

Version267

Amazon GameLift Manuel du développeurUtilisation de la mise en relation FlexMatch

Utilisation de la mise en relation FlexMatchLorsque vous utilisez une solution GameLift gérée, utilisez ces opérations pour configurer la mise enrelation personnalisée pour votre jeu et demander la mise en relation pour les joueurs. Vous pouvez ajouterFlexMatch à des jeux avec une version de jeu personnalisée ou Serveurs en temps réel.

Configurer les règles et le processus de mise en relationConfigurez un matchmaker FlexMatch et définissez un ensemble de règles pour créer des matchs et deséquipes.

Configuration de la mise en relation

• CreateMatchmakingConfiguration – Créer une configuration de mise en relation avec des instructionspour créer un groupe de joueurs et le placer dans une nouvelle session de jeu.

• DescribeMatchmakingConfigurations – Récupérer les configurations de mise en relation définies par unerégion GameLift.

• UpdateMatchmakingConfiguration – Modifier les paramètres pour la file d'attente de configuration demise en relation.

• DeleteMatchmakingConfiguration – Supprimer une configuration de mise en relation de la région.

Ensemble de règles de mise en relation

• CreateMatchmakingRuleSet – Créer un ensemble de règles à utiliser lors de la recherche d’adéquationde joueurs.

• DescribeMatchmakingRuleSets – Récupérer les ensembles de règles de mise en relation définis dansune région GameLift.

• ValidateMatchmakingRuleSet – Vérifier la syntaxe d'un ensemble de règles de mise en relation.• DeleteMatchmakingRuleSet – Supprimer un ensemble de règles de mise en relation de la région.

Demander une mise en relation.Appelez ces opérations depuis votre service client de jeu pour gérer les demandes de mise en relation desjoueurs. Les matchs réussis sont automatiquement placés dans une nouvelle session de jeu.

• StartMatchmaking – Demander une mise en relation pour un joueur ou un groupe qui souhaite jouerensemble.

• DescribeMatchmaking – Obtenir des détails sur une demande de mise en relation, y compris le statut.• AcceptMatch – Pour une adéquation qui nécessite l'acceptation du joueur, procéder à l’inscription

lorsqu'un joueur accepte une adéquation proposée.• StopMatchmaking – Annuler une demande de mise en relation.• StartMatchBackfill - Demander des adéquations de joueur supplémentaires pour remplir des

emplacements vides dans une session de jeu existante.

Utilisation des GameLift FleetIQLorsque vous utilisez la solution autonome GameLift FleetIQ, utilisez ces opérations pour gérer les groupesde serveurs de jeux et les serveurs de jeux hébergés avec des ressources Amazon EC2 en conjonctionavec des groupes Auto Scaling.

Groupes de serveurs de jeux

Version268

Amazon GameLift Manuel du développeurLangages de programmation disponibles

• CreateGameServerGroup – Créez un nouveau groupe de serveurs de jeux et un groupe Auto Scalingcorrespondant, puis commencez à lancer des instances pour héberger votre serveur de jeux.

• ListGameServerGroups – Obtenez une liste de tous les groupes de serveurs de jeux dans une régionGameLift.

• DescribeGameServerGroup – Récupérez les métadonnées d'un groupe de serveurs de jeux.• UpdateGameServerGroup – Modifiez les métadonnées d'un groupe de serveurs de jeux.• DeleteGameServerGroup – Supprimez définitivement un groupe de serveurs de jeux et mettez fin à

l'activité FleetIQ des ressources d'hébergement associées.• ResumeGameServerGroup – Rétablissez l'activité FleetIQ suspendue pour un groupe de serveurs de

jeux.• SuspendGameServerGroup – Arrêtez temporairement l'activité FleetIQ d'un groupe de serveurs de jeux.

Serveurs de jeux

• RegisterGameServer – Appelez à partir d'un nouveau serveur de jeu pour avertir GameLift FleetIQ que leserveur de jeu est prêt à héberger le jeu.

• ListGameServers – Appelez à partir d'un service client de jeu pour obtenir la liste de tous les serveurs dejeu actuellement en cours d'exécution dans un groupe de serveurs de jeu.

• ClaimGameServer – Appelez à partir d'un service client de jeu pour localiser et réserver un serveur dejeu pour héberger une nouvelle session de jeu.

• DescribeGameServer – Récupérez les métadonnées d'un serveur de jeux.• UpdateGameServer – Modifiez les métadonnées du serveur de jeux, l'état d'intégrité ou l'état d'utilisation.• DeRegisterGameServer – Appel à partir d'un serveur de jeu qui se termine pour demander à GameLift

FleetIQ de supprimer le serveur de jeu du groupe de serveurs de jeu.

Langages de programmation disponiblesLe kit AWS SDK avec Amazon GameLift est disponible dans les langages suivants. Consultez ladocumentation pour chaque langage et en savoir plus sur la prise en charge des environnements dedéveloppement.

• C++ (Docs SDK) (Amazon GameLift)• Java (Docs SDK) (Amazon GameLift)• .NET (Docs SDK) (Amazon GameLift)• Go (Docs SDK) (Amazon GameLift)• Python (Docs SDK) (Amazon GameLift)• Ruby (Docs SDK) (Amazon GameLift)• PHP (Docs SDK) (Amazon GameLift)• JavaScript/Node.js ((Docs SDK) (Amazon GameLift)

Référence Amazon GameLift Serveurs en tempsréel

Cette section contient la documentation de référence du kit SDK Amazon GameLift Serveurs en temps réel.Il inclut l'API client RealTime, ainsi que des conseils pour configurer votre script Serveurs en temps réel.

Version269

Amazon GameLift Manuel du développeurRéférence d'API de client en temps réel (C#)

Rubriques• Référence d'API de client Serveurs en temps réel (C#) (p. 270)• Référence des scripts des Serveurs en temps réel Amazon GameLift (p. 280)

Référence d'API de client Serveurs en temps réel (C#)Utilisez l'API de client RealTime pour préparer vos clients de jeux multijoueur à une utilisation d'AmazonGameLift Serveurs en temps réel. Pour plus d'informations sur le processus d'intégration, consultezPremiers pas avec Serveurs en temps réel (p. 35). L'API de client contient un ensemble de rappels d'APIsynchrones et asynchrones qui permettent à un client de jeu de se connecter à un serveur RealTime etd'échanger des messages et des données avec d'autres clients de jeu via le serveur.

Cet API est défini dans les bibliothèques suivantes :

Client.cs

• Actions synchrones (p. 270)• Rappels asynchrones (p. 274)• Types de données (p. 276)

Configuration de l'API de client RealTime

1. Téléchargez le kit SDK de client Amazon GameLift RealTime.2. Développez les bibliothèques SDK C#. Localisez le fichier de solution

GameScaleLightweightClientSdkNet45.sln. Consultez le fichier README.md relatif au kit SDKC# Server pour connaître la configuration minimale requise et les options de build supplémentaires.Chargez le fichier de solution dans un IDE. Pour générer les bibliothèques SDK, restaurez lespackages Nuget et développez la solution.

3. Ajoutez les bibliothèques de client RealTime au projet de votre client de jeu.

Référence API client Serveurs en temps réel (C#) : ActionsCette référence d'API client RealTime C# peut vous aider à préparer votre jeu multijoueur pour uneutilisation avec les Serveurs en temps réel déployés sur des flottes Amazon GameLift. Pour plusd'informations sur le processus d'intégration, consultez Premiers pas avec Serveurs en temps réel (p. 35).

• Actions synchrones• Rappels asynchrones (p. 274)• Types de données (p. 276)

Client()

Initialise un nouveau client pour communiquer avec le serveur Realtime et identifie le type de connexion àutiliser.

Syntaxe

public Client(ClientConfiguration configuration)

Version270

Amazon GameLift Manuel du développeurRéférence d'API de client en temps réel (C#)

Paramètres

clientConfiguration

Détails de configuration spécifiant le type de connexion client/serveur. Vous pouvez choisir d'appelerClient() sans ce paramètre ; cependant, cette approche se traduit par une connexion non sécurisée pardéfaut.

Type: ClientConfiguration (p. 277)

Requis : non

Valeur renvoyée

Renvoie une instance du client Realtime à utiliser avec la communication avec le serveur Realtime.

Connect()

Demande une connexion à un processus serveur qui héberge une session de jeu.

Syntaxe

public ConnectionStatus Connect(string endpoint, int remoteTcpPort, int listenPort, ConnectionToken token)

Paramètres

endpoint

Adresse IP ou nom DNS de la session de jeu à laquelle se connecter. Le point de terminaison estspécifié dans un objet GameSession, qui est renvoyé en réponse à un appel du client aux actionsde l'API AWS SDK Amazon GameLift StartGameSessionPlacement, à CreateGameSession ou à unedemande DescribeGameSessions.

Note

Si le serveur Realtime s'exécute sur une flotte avec un certificat TLS, vous devez utiliser lenom DNS.

Type : chaîne

Obligatoire : ouiremoteTcpPort

Numéro de port pour la connexion TCP attribuée à la session de jeu. Ces informationssont spécifiées dans un objet GameSession, qui est renvoyé en réponse à une demandeStartGameSessionPlacement CreateGameSession ou une demande DescribeGameSession.

Type : entier

Valeurs valides : 1900 à 2000.

Obligatoire : ouilistenPort

Numéro de port que le client de jeu surveille pour des messages envoyés à l'aide du canal UDP.

Type : entier

Version271

Amazon GameLift Manuel du développeurRéférence d'API de client en temps réel (C#)

Valeurs valides : 33400 à 33500.

Obligatoire : ouitoken

Informations facultatives qui identifient la demande client de jeu au processus serveur.

Type : ConnectionToken (p. 277)

Obligatoire : oui

Valeur renvoyée

Renvoie une valeur enum ConnectionStatus (p. 279) indiquant l'état de la connexion du client.

Disconnect()Lorsque vous êtes connecté à une session de jeu, déconnecte le client de jeu à partir de la session de jeu.

Syntaxe

public void Disconnect()

Paramètres

Cette action n'a aucun paramètre.

Valeur renvoyée

Cette méthode ne renvoie rien.

NewMessage()Crée un nouvel objet de message avec un code d'opération spécifié. Une fois qu'un message est renvoyé,complétez le contenu du message en spécifiant une cible, en mettant à jour le mode de remise, et enajoutant une charge utile de données en fonction de vos besoins. Une fois terminé, envoyez le message àl'aide de SendMessage().

Syntaxe

public RTMessage NewMessage(int opCode)

Paramètres

opCode

Code d'opération défini par le développeur qui identifie un événement ou une action de jeu, parexemple un mouvement de joueur ou une notification.

Type : entier

Obligatoire : oui

Valeur renvoyée

Renvoie un objet RTMessage (p. 277) contenant l'opération spécifiée par défaut et la méthode delivraison de code. Le paramètre d'intention d'acheminement est défini sur FAST par défaut.

Version272

Amazon GameLift Manuel du développeurRéférence d'API de client en temps réel (C#)

SendMessage()Envoie un message à un joueur ou un groupe à l'aide de la méthode de livraison spécifiée.

Syntaxe

public void SendMessage(RTMessage message)

Paramètres

message

Message d'objet qui spécifie le destinataire cible, la méthode de livraison et le contenu du message.

Type : RTMessage (p. 277)

Obligatoire : oui

Valeur renvoyée

Cette méthode ne renvoie rien.

JoinGroup()Ajoute le joueur à un groupe spécifié. Les groupes peuvent contenir n'importe quel joueur connecté aujeu. Une fois qu'il a rejoint le serveur, le joueur reçoit tous les futurs messages envoyés au groupe et peutenvoyer des messages à l'ensemble du groupe.

Syntaxe

public void JoinGroup(int targetGroup)

Paramètres

targetGroup

ID unique qui identifie le groupe auquel ajouter le joueur. Les ID de groupe sont définis par ledéveloppeur.

Type : entier

Obligatoire : oui

Valeur renvoyée

Cette méthode ne renvoie rien. Étant donné que cette demande est envoyée à l'aide de la méthode delivraison fiable (TCP), un échec de demande déclenche le rappel OnError() (p. 275).

LeaveGroup()Retire le joueur d'un groupe spécifié. Une fois qu'il n'est plus dans le groupe, le joueur ne reçoit pas lesmessages envoyés au groupe et ne peut envoyer de messages à l'ensemble du groupe.

Syntaxe

public void LeaveGroup(int targetGroup)

Version273

Amazon GameLift Manuel du développeurRéférence d'API de client en temps réel (C#)

Paramètres

targetGroup

ID unique qui identifie le groupe duquel retirer le joueur. Les ID de groupe sont définis par ledéveloppeur.

Type : entier

Obligatoire : oui

Valeur renvoyée

Cette méthode ne renvoie rien. Étant donné que cette demande est envoyée à l'aide de la méthode delivraison fiable (TCP), un échec de demande déclenche le rappel OnError() (p. 275).

RequestGroupMembership()

Demande qu'une liste de joueurs dans le groupe spécifié soit envoyée au client de jeu. Tout joueur peutdemander ces informations, qu'il s'agisse ou non d'un membre du groupe. En réponse à cette demande, laliste d'adhésion est envoyée au client via un rappel OnGroupMembershipUpdated() (p. 276).

Syntaxe

public void RequestGroupMembership(int targetGroup)

Paramètres

targetGroup

ID unique qui identifie le groupe pour lequel obtenir des informations sur l'adhésion. Les ID de groupesont définis par le développeur.

Type : entier

Obligatoire : oui

Valeur renvoyée

Cette méthode ne renvoie rien.

Référence d'API de client (C#) Serveurs en temps réel : RappelsasynchronesUtilisez cette référence d'API client RealTime C# pour vous aider à préparer votre jeu multijoueur à uneutilisation avec Serveurs en temps réel déployé sur des flottes Amazon GameLift. Pour plus d'informationssur le processus d'intégration, consultez Premiers pas avec Serveurs en temps réel (p. 35).

• Actions synchrones (p. 270)• Rappels asynchrones• Types de données (p. 276)

Un client de jeu a besoin de mettre en œuvre ces méthodes de rappel pour répondre aux événements.Le serveur RealTime invoque ces rappels pour envoyer des informations liées au jeu pour le client de

Version274

Amazon GameLift Manuel du développeurRéférence d'API de client en temps réel (C#)

jeu. Les rappels pour les mêmes événements peuvent également être mis en œuvre avec une logique dejeu personnalisée dans le script de serveur RealTime. Voir Rappels de scripts pour Serveurs en tempsréel (p. 280).

Les méthodes de rappel sont définies dans ClientEvents.cs.

OnOpen()

Appelée lorsque le processus serveur accepte la demande de connexion d'un client de jeu et ouvre uneconnexion.

Syntaxe

public void OnOpen()

Paramètres

Cette méthode ne prend aucun paramètre.

Valeur renvoyée

Cette méthode ne renvoie rien.

OnClose()

Appelée lorsque le processus serveur met fin à la connexion avec le client de jeu, comme lorsqu'unesession de jeu se termine.

Syntaxe

public void OnClose()

Paramètres

Cette méthode ne prend aucun paramètre.

Valeur renvoyée

Cette méthode ne renvoie rien.

OnError()

Appelée lorsqu'un échec se produit pour une demande d'API du client en temps réel. Ce rappel peut êtrepersonnalisé afin de prendre en charge une grande variété d'erreurs de connexion.

Syntaxe

private void OnError(byte[] args)

Paramètres

Cette méthode ne prend aucun paramètre.

Valeur renvoyée

Cette méthode ne renvoie rien.

Version275

Amazon GameLift Manuel du développeurRéférence d'API de client en temps réel (C#)

OnDataReceived()Appelée lorsque le client de jeu reçoit un message à partir du serveur RealTime. Il s'agit de la méthodeprincipale de réception de messages et de notifications par un client de jeu.

Syntaxe

public void OnDataReceived(DataReceivedEventArgs dataReceivedEventArgs)

Paramètres

dataReceivedEventArgs

Informations liées à l'activité de messages.

Type : DataReceivedEventArgs (p. 278)

Obligatoire : oui

Valeur renvoyée

Cette méthode ne renvoie rien.

OnGroupMembershipUpdated()Appelée lorsque l'adhésion à un groupe auquel le joueur appartient a été mise à jour. Ce rappel estégalement invoqué lorsqu'un client appelle RequestGroupMembership.

Syntaxe

public void OnGroupMembershipUpdated(GroupMembershipEventArgs groupMembershipEventArgs)

Paramètres

groupMembershipEventArgs

Informations liées à l'activité d'adhésion d'un groupe.

Type : GroupMembershipEventArgs (p. 279)

Obligatoire : oui

Valeur renvoyée

Cette méthode ne renvoie rien.

Référence d'API de client (C#) Serveurs en temps réel : Types dedonnéesCette référence d'API client RealTime C# peut vous aider à préparer votre jeu multijoueur pour uneutilisation avec les Serveurs en temps réel déployés sur des flottes Amazon GameLift. Pour plusd'informations sur le processus d'intégration, consultez Premiers pas avec Serveurs en temps réel (p. 35).

• Actions synchrones (p. 270)• Rappels asynchrones (p. 274)• Types de données

Version276

Amazon GameLift Manuel du développeurRéférence d'API de client en temps réel (C#)

ClientConfigurationInformations sur la façon dont le client de jeu se connecte à un serveur RealTime.

Table des matières

ConnectionType

Type de connexion client/serveur à utiliser, sécurisée ou non sécurisée. Si vous ne spécifiez pas detype de connexion, la valeur par défaut est non sécurisée.

Note

Lors de la connexion à un serveur en temps réel sur une flotte sécurisée avec un certificatTLS, vous devez utiliser la valeur RT_OVER_WSS_DTLS_TLS12.

Type : valeur ConnectionType enum (p. 279) .

Requis : non

ConnectionTokenInformations sur le client de jeu et/ou le joueur qui demande une connexion à un serveur RealTime.

Sommaire

playerSessionId

ID unique émis par GameLift lorsqu'une nouvelle session de joueur est créée. L'ID de session dejoueur est spécifié dans un objet PlayerSession qui est renvoyé en réponse à un appel du client auxactions de l'API AWS SDK Amazon GameLift StartGameSessionPlacement, CreateGameSession, DescribeGameSessionPlacement ou DescribePlayerSessions.

Type : chaîne

Requis : nonpayload

Informations définies par le développeur à communiquer au serveur RealTime au moment de laconnexion. Cela inclut toutes les données arbitraires qui peuvent être utilisées pour un mécanisme deconnexion personnalisé. Pour obtenir des exemples, une charge utile peut fournir des informationsd'authentification à traiter par le script de serveur RealTime avant d'autoriser la connexion d'un client.

Type : tableau d'octets

Obligatoire : non

RTMessageContenu et informations de livraison pour un message. Un message doit spécifier soit un joueur ou ungroupe cible.

Sommaire

opCode

Code d'opération défini par le développeur qui identifie un événement ou une action de jeu, parexemple un mouvement de joueur ou une notification. Un code Op d'un message fournit le contextepour les données utiles qui sont fournies. Les messages qui sont créés en utilisant NewMessage()disposent déjà du code d'opération défini, mais celui-ci peut être modifié à tout moment.

Version277

Amazon GameLift Manuel du développeurRéférence d'API de client en temps réel (C#)

Type : entier

Obligatoire : ouitargetPlayer

ID unique qui identifie le destinataire voulu du message envoyé. La cible peut être le serveur lui-même(en utilisant l'ID de serveur) ou un autre joueur (à l'aide d'un ID de joueur).

Type : entier

Obligatoire : nontargetGroup

ID unique qui identifie le groupe destinataire voulu du message envoyé. Les ID de groupe sont définispar le développeur.

Type : entier

Obligatoire : nondeliveryIntent

Indique s'il convient d'envoyer le message à l'aide de la connexion TCP fiable ou à l'aide du canal UDPrapide. Messages créés à l'aide de NewMessage() (p. 272).

Type : DeliveryIntent enum

Valeurs valides : RAPIDE | FIABLE

Obligatoire : ouipayload

Contenu du message. Ces informations sont structurées de telle manière à être traitées par le clientde jeu en fonction du code d'opération connexe. Elles peuvent contenir des données d'état du jeu oud'autres informations qui doivent être communiquées entre les clients de jeu ou entre un client de jeuet le serveur en temps réel.

Type : tableau d'octets

Obligatoire : non

DataReceivedEventArgs

Les données fournies avec un rappel OnDataReceived() (p. 276).

Sommaire

expéditeur

ID unique qui identifie l'entité (ID de joueur ou ID de serveur) ayant transmis le message.

Type : entier

Obligatoire : ouiopCode

Code d'opération défini par le développeur qui identifie un événement ou une action de jeu, parexemple un mouvement de joueur ou une notification. Un code Op d'un message fournit le contextepour les données utiles qui sont fournies.

Version278

Amazon GameLift Manuel du développeurRéférence d'API de client en temps réel (C#)

Type : entier

Obligatoire : ouiDonnées

Contenu du message. Ces informations sont structurées de telle manière à être traitées par le clientde jeu en fonction du code d'opération connexe. Elles peuvent contenir des données d'état du jeu oud'autres informations qui doivent être communiquées entre les clients de jeu ou entre un client de jeuet le serveur en temps réel.

Type : tableau d'octets

Obligatoire : non

GroupMembershipEventArgs

Les données fournies avec un rappel OnGroupMembershipUpdated() (p. 276).

Sommaire

expéditeur

ID unique qui identifie le joueur qui a demandé une mise à jour d'adhésion au groupe.

Type : entier

Obligatoire : ouiopCode

Code d'opération défini par le développeur qui identifie un événement ou une action de jeu.

Type : entier

Obligatoire : ouigroupId

ID unique qui identifie le groupe destinataire voulu du message envoyé. Les ID de groupe sont définispar le développeur.

Type : entier

Obligatoire : ouiplayerId

Liste des ID de joueurs qui sont actuellement membres du groupe spécifié.

Type : tableau integer

Obligatoire : oui

Enums

Les enums définies pour le kit SDK de client RealTime sont définies comme suit :

ConnectionStatus• CONNECTED – Le client de jeu est connecté au serveur RealTime uniquement avec une connexion

TCP. Tous les messages sont envoyés via TCP ; indépendamment de l'intention de livraison.

Version279

Amazon GameLift Manuel du développeurRéférence des scripts des Serveurs en temps réel

• CONNECTED_SEND_FAST – Le client de jeu est connecté au serveur RealTime avec uneconnexion TCP et UDP. Cependant, la capacité de recevoir des messages via UDP n'est pas encorevérifiée. Par conséquent, tous les messages envoyés au client de jeu utilisent TCP.

• CONNECTED_SEND_AND_RECEIVE_FAST – Le client de jeu est connecté au serveur RealTimeavec une connexion TCP et UDP. Le client de jeu peut envoyer et recevoir des messages à l'aide deTCP ou UDP.

• CONNECTING Le client de jeu a envoyé une demande de connexion et le serveur RealTime est encours de traitement.

• DISCONNECTED_CLIENT_CALL – Le client de jeu a été déconnecté du serveur RealTime enréponse à une demande Disconnect() (p. 272) du client de jeu.

• DISCONNECTED – Le client de jeu a été déconnecté du serveur RealTime pour une raison autrequ'un appel de déconnexion de client.

ConnectionType• RT_OVER_WSS_DTLS_TLS12 – Type de connexion sécurisée.

À utiliser avec les serveurs en temps réel qui s'exécutent sur une flotte GameLift avec un certificatTLS généré. Lorsque vous utilisez une connexion sécurisée, le trafic TCP est chiffré à l'aide de TLS1.2 et le trafic UDP est chiffré à l'aide de DTLS 1.2.

• RT_OVER_WS_UDP_UNSECURED – Type de connexion non sécurisée.• RT_OVER_WEBSOCKET – Type de connexion non sécurisée. Cette valeur n'est plus préférée.

DeliveryIntent• FAST – Livré à l'aide d'un canal UDP.• RELIABLE – Livré à l'aide d'une connexion TCP.

Référence des scripts des Serveurs en temps réelAmazon GameLiftUtilisez ces ressources pour développer une logique personnalisée dans vos scripts RealTime.

Rubriques• Rappels de scripts pour Serveurs en temps réel (p. 280)• Interface Serveurs en temps réel (p. 282)

Rappels de scripts pour Serveurs en temps réelVous pouvez fournir une logique personnalisée pour répondre à des événements en mettant en œuvre cesrappels dans votre script RealTime.

init

Initialise le serveur RealTime et reçoit une interface de serveur en temps réel.

Syntaxe

init(rtsession)

onMessage

Appelé lorsqu'un message reçu est envoyé au serveur.

Version280

Amazon GameLift Manuel du développeurRéférence des scripts des Serveurs en temps réel

Syntaxe

onMessage(gameMessage)

onHealthCheck

Appelé pour définir le statut d'intégrité de la session de jeu. Par défaut, le statut d'intégrité est sain (outrue). Ce rappel peut être implémenté pour effectuer des vérifications de l'état personnalisées et renvoyerun statut.

Syntaxe

onHealthCheck()

onStartGameSession

Appelé lorsqu'une nouvelle session de jeu démarre, avec un objet de session de jeu transmis.

Syntaxe

onStartGameSession(session)

onProcessTerminate

Appelé lorsque le processus serveur est en cours de résiliation par le service Amazon GameLift. Il peutagir comme déclencheur pour quitter de façon nette la session de jeu. Il n'y a pas besoin d'appelerprocessEnding().

Syntaxe

onProcessTerminate()

onPlayerConnect

Appelé lorsqu'un joueur demande une connexion et a réussi la validation initiale.

Syntaxe

onPlayerConnect(connectMessage)

onPlayerAccepted

Appelé lorsqu'une connexion de joueur est acceptée.

Syntaxe

onPlayerAccepted(player)

onPlayerDisconnect

Appelé lorsqu'un joueur se déconnecte de la session de jeu, que ce soit en envoyant une demande dedéconnexion ou par d'autres moyens.

Version281

Amazon GameLift Manuel du développeurRéférence des scripts des Serveurs en temps réel

Syntaxe

onPlayerDisconnect(peerId)

onProcessStarted

Appelé lorsqu'un processus serveur est démarré. Ce rappel autorise le script à effectuer toutes les tâchespersonnalisées nécessaires pour préparer l'hébergement d'une session de jeu.

Syntaxe

onProcessStarted(args)

onSendToPlayer

Appelé lorsqu'un message est reçu sur le serveur d'un joueur pour être livré à un autre joueur. Ceprocessus s'exécute avant que le message soit livré.

Syntaxe

onSendToPlayer(gameMessage)

onSendToGroup

Appelé lorsqu'un message est reçu sur le serveur d'un joueur pour être livré à un groupe. Ce processuss'exécute avant que le message soit livré.

Syntaxe

onSendToGroup(gameMessage))

onPlayerJoinGroup

Appelé lorsqu'un joueur envoie une demande pour rejoindre un groupe.

Syntaxe

onPlayerJoinGroup(groupId, peerId)

onPlayerLeaveGroup

Appelé lorsqu'un joueur envoie une demande pour quitter un groupe.

Syntaxe

onPlayerLeaveGroup(groupId, peerId)

Interface Serveurs en temps réelLorsqu'un script RealTime est initialisé, une interface pour le serveur RealTime est renvoyée. Cetterubrique décrit les propriétés et les méthodes disponibles via cette interface. Obtenez plus d'informations

Version282

Amazon GameLift Manuel du développeurRéférence des scripts des Serveurs en temps réel

sur l'écriture de scripts RealTime et consultez un exemple de script détaillé dans Création d'un scriptRealTime (p. 71).

L'interface RealTime permet d'accéder aux objets suivants :

• session• joueur (player)• message de jeu (gameMessage)

Objet session RealTime

Utilisez ces méthodes pour accéder aux informations liées au serveur et effectuer des actions liées auserveur.

getPlayers()

Récupère la liste des ID de pair pour les joueurs actuellement connectés à la session de jeu. Renvoie untableau d'objets joueur.

Syntaxe

rtSession.getPlayers()

broadcastGroupMembershipUpdate()

Déclenche la livraison d'une mise à jour de la liste des membres d'un groupe de joueurs. Spécifiezl'appartenance à diffuser (groupIdToBroadcast) et le groupe qui doit recevoir la mise à jour (targetGroupId).

Syntaxe

rtSession.broadcastGroupMembershipUpdate(groupIdToBroadcast, targetGroupId)

getServerId()

Récupère l'identifiant de pair unique du serveur, qui est utilisé pour router les messages vers le serveur.

Syntaxe

rtSession.getServerId()

getAllPlayersGroupId()

Récupère l'ID de groupe pour le groupe par défaut qui contient tous les joueurs actuellement connectés àla session de jeu.

Syntaxe

rtSession.getAllPlayersGroupId()

processEnding()

Déclenche la résiliation du serveur de jeu par le serveur RealTime. Cette fonction doit être appelée depuisle script RealTime pour quitter de façon nette une session de jeu.

Version283

Amazon GameLift Manuel du développeurRéférence des scripts des Serveurs en temps réel

Syntaxe

rtSession.processEnding()

getGameSessionId()

Récupère l'ID unique de la session de jeu en cours d'exécution.

Syntaxe

rtSession.getGameSessionId()

getLogger()

Récupère l'interface pour la journalisation. Utilisez cette commande pour consigner les instructions quiseront capturées dans vos journaux de session de jeu. L'enregistreur prend en charge les instructions« info », « warn » et « error ». Par exemple : logger.info("<string>").

Syntaxe

rtSession.getLogger()

sendMessage()

Envoie un message, créé à l'aide de newTextGameMessage ou newBinaryGameMessage, à partir duserveur RealTime à un joueur destinataire à l'aide du canal UDP. Identifiez le destinataire à l'aide de l'ID depair du joueur.

Syntaxe

rtSession.sendMessage(gameMessage, targetPlayer)

sendGroupMessage()

Envoie un message, créé à l'aide de newTextGameMessage ou newBinaryGameMessage, à partirdu serveur RealTime à tous les joueurs d'un groupe de joueurs à l'aide du canal UDP. Identifiez lesdestinataires à l'aide de l'ID de groupe.

Syntaxe

rtSession.sendGroupMessage(gameMessage, targetGroup)

sendReliableMessage()

Envoie un message, créé à l'aide de newTextGameMessage ou newBinaryGameMessage, à partir duserveur RealTime à un joueur destinataire à l'aide du canal TCP. Identifiez le destinataire à l'aide de l'ID depair du joueur.

Syntaxe

rtSession.sendReliableMessage(gameMessage, targetPlayer)

Version284

Amazon GameLift Manuel du développeurRéférence des scripts des Serveurs en temps réel

sendReliableGroupMessage()

Envoie un message, créé à l'aide de newTextGameMessage ou newBinaryGameMessage, à partirdu serveur RealTime à tous les joueurs d'un groupe de joueurs à l'aide du canal TCP. Identifiez lesdestinataires à l'aide de l'ID de groupe.

Syntaxe

rtSession.sendReliableGroupMessage(gameMessage, targetGroup)

newTextGameMessage()

Crée un message contenant du texte, qui doit être envoyé à partir du serveur aux joueurs destinataires àl'aide des fonctions SendMessage. Le format du message est similaire au format utilisé dans le kit SDK declient en temps réel (voir RTMessage (p. 277)). Renvoie un objet gameMessage.

Syntaxe

rtSession.newTextGameMessage(opcode, sender, payload)

newBinaryGameMessage()

Crée un nouveau message contenant des données binaires, qui doit être envoyé à partir du serveuraux joueurs destinataires à l'aide des fonctions SendMessage. Le format du message est similaire auformat utilisé dans le kit SDK de client en temps réel (voir RTMessage (p. 277)). Renvoie un objetgameMessage.

Syntaxe

rtSession.newBinaryGameMessage(opcode, sender, binaryPayload)

Objet joueur

Accédez aux informations liées au joueur.

player.peerId

ID unique affecté à un client de jeu lorsqu'il se connecte au serveur RealTime et rejoint la session de jeu.

player.playerSessionId

ID de session de joueur qui a été référencé par le client de jeu lorsqu'il s'est connecté au serveur RealTimeet a rejoint la session de jeu.

Objet message de jeu

Utilisez ces méthodes pour accéder aux messages qui sont reçus par le serveur RealTime. Les messagesreçus des clients de jeu ont la structure RTMessage (p. 277).

gameMessage.opcode

Code d'opération contenu dans un message.

gameMessage.payload

Charge utile contenue dans un message. Peut être de type texte ou binaire.

Version285

Amazon GameLift Manuel du développeurRéférence SDK Server

gameMessage.senderID de pair du client de jeu qui a envoyé un message.

gameMessage.reliableBooléen indiquant si le message a été envoyé via TCP (true) ou UDP (false).

Référence SDK Server Amazon GameLiftCette section contient la documentation de référence pour le SDK Server Amazon GameLift. Utilisez le kitSDK Server pour intégrer votre serveur de jeu personnalisé avec le service Amazon GameLift pour lanceret gérer des serveurs de jeux en fonction des besoins.

Rubriques• Référence d'API GameLift Server pour C++ (p. 286)• Référence d'API GameLift Server pour C++ (p. 301)• GameLift Référence d’API de serveur pour Unreal Engine (p. 316)

Référence d'API GameLift Server pour C++Cette référence d'API de serveur C++ GameLift peut vous aider à préparer votre jeu multijoueur pourune utilisation avec GameLift. Pour plus d'informations sur le processus d'intégration, consultez AjouterGameLift vers votre serveur de jeux (p. 46).

Cette API est définie dans GameLiftServerAPI.h, LogParameters.h et ProcessParameters.h.

• Actions: (p. 286)• Types de données (p. 297)

Référence d'API GameLift Server pour C++ Actions:Cette référence d'API de serveur C++ GameLift peut vous aider à préparer votre jeu multijoueur pourune utilisation avec GameLift. Pour plus d'informations sur le processus d'intégration, consultez AjouterGameLift vers votre serveur de jeux (p. 46).

Cette API est définie dans GameLiftServerAPI.h, LogParameters.h, ProcessParameters.h .

• Actions:• Types de données (p. 297)

AcceptPlayerSession()Informe le service GameLift qu'un joueur avec l'ID de session de joueur spécifié s'est connecté auprocessus serveur et attend une validation. GameLift vérifie que l'ID de session de joueur est valide, c'est-à-dire que l'ID de joueur a réservé un emplacement de joueur dans la session de jeu. Une fois la validationeffectuée, GameLift fait passer l'emplacement de joueur de l'état RESERVED à ACTIVE.

Syntax

GenericOutcome AcceptPlayerSession(const std::string& playerSessionId);

Version286

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

Parameters

playerSessionId

ID unique émis par le service Amazon GameLift en réponse à un appel d'API du kit AWS SDKAmazon GameLiftCreatePlayerSession. Le client de jeu fait référence à cet ID lors de la connexion auprocessus serveur.

Type : std::string

Requis : non

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Example

Cet exemple illustre une fonction pour le traitement d'une demande de connexion, y compris la validation etle rejet des ID de session joueur non valides.

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()Informe le service GameLift que le processus serveur a démarré une session de jeu et est maintenant prêtà recevoir les connexions de joueurs. Cette action doit être appelée dans le cadre de la fonction de rappelonStartGameSession(), une fois que l'initialisation de toutes les sessions de jeu est terminée.

Syntax

GenericOutcome ActivateGameSession();

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Example

Cet exemple illustre l'appel de ActivateGameSession() dans le cadre de la fonction de rappelonStartGameSession().

void onStartGameSession(Aws::GameLift::Model::GameSession myGameSession)

Version287

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

{ // game-specific tasks when starting a new game session, such as loading map GenericOutcome outcome = Aws::GameLift::Server::ActivateGameSession();}

DescribePlayerSessions()Récupère les données de session de joueur, y compris les paramètres, les métadonnées de session et lesdonnées de joueur. Utilisez cette action pour obtenir des informations pour une seule session de joueur,pour toutes les sessions de joueur d'une session de jeu ou pour toutes les sessions de joueur associées àun seul ID de joueur.

Syntax

DescribePlayerSessionsOutcome DescribePlayerSessions ( const Aws::GameLift::Server::Model::DescribePlayerSessionsRequest &describePlayerSessionsRequest);

Parameters

describePlayerSessionsRequest

Objet DescribePlayerSessionsRequest (p. 297) décrivant les sessions de joueur à récupérer.

 : obligatoire.  : oui

Valeur renvoyée

En cas de réussite, renvoie un objet DescribePlayerSessionsOutcome qui contient un ensembled'objets de session de joueur correspondant aux paramètres de la demande. La structure des objets desessions de joueur est identique au type de données de l'API GameLift du AWS SDK PlayerSession.

Example

Cet exemple illustre une demande de toutes les sessions de joueur activement connectées à une sessionde jeu spécifiée. Si vous omettez NextToken et définissez la valeur de Limit sur 10, GameLift renvoie les10 premiers enregistrements de sessions de joueur qui correspondent à la demande.

// 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);request.SetGameSessionId("the game session ID"); // can use GetGameSessionId()

// Call DescribePlayerSessionsAws::GameLift::DescribePlayerSessionsOutcome playerSessionsOutcome = Aws::GameLift::Server::DescribePlayerSessions(request);

GetGameSessionId()Extrait un identifiant unique pour la session de jeu actuellement hébergée par leprocessus serveur, si ce dernier est actif. L'identifiant est retourné dans un format ARN : .arn:aws:gamelift:<region>::gamesession/fleet-<fleet ID>/<ID string>.

Syntax

AwsStringOutcome GetGameSessionId();

Version288

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

En cas de réussite, renvoie l'ID de session de jeu en tant qu'objet AwsStringOutcome. En cas d'échec,renvoie un message d'erreur.

Example

Aws::GameLift::AwsStringOutcome sessionIdOutcome = Aws::GameLift::Server::GetGameSessionId();

GetInstanceCertificate ()Récupère l'emplacement de fichier d'un certificat TLS codé pem qui est associé au parc et à ses instances.Ce certificat est généré lorsqu'une nouvelle flotte est créée avec la configuration de certificat définie surGENERATED. Utilisez ce certificat pour établir une connexion sécurisée avec un client de jeu et pourchiffrer la communication client/serveur.

Syntax

GetInstanceCertificateOutcome GetInstanceCertificate();

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

En cas de réussite, renvoie un objet GetInstanceCertificateOutcome contenant l'emplacementdu fichier de certificat TLS de la flotte, qui est stocké sur l'instance. En cas d'échec, renvoie un messaged'erreur.

Example

Aws::GameLift::GetInstanceCertificateOutcome certificateOutcome = Aws::GameLift::Server::GetInstanceCertificate();

GetSdkVersion()Renvoie numéro de version actuel du kit SDK en cours d'utilisation.

Syntax

AwsStringOutcome GetSdkVersion();

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

En cas de réussite, renvoie la version actuelle du kit SDK en tant qu'objet AwsStringOutcome. La chaînerenvoyée inclut uniquement le numéro de version (par ex. « 3,15 pouces »). En cas d'échec, renvoie unmessage d'erreur.

Version289

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

Example

Aws::GameLift::AwsStringOutcome SdkVersionOutcome = Aws::GameLift::Server::GetSdkVersion();

GetTerminationTime()

Renvoie l'heure d'arrêt planifiée pour un processus serveur, si une heure de résiliation est disponible. Unprocessus serveur effectue cette action après avoir reçu un onProcessTerminate() rappel depuisle GameLift du service après-vente. GameLift peut appeler onProcessTerminate() pour les raisonssuivantes : (1) en raison d’un mauvais état de santé (le processus serveur a signalé un état de santé duport ou n’a pas répondu à GameLift, (2) lors de la mise hors service de l’instance lors d’un événement dediminution de charge, ou (3) lorsqu’une instance est mise hors service en raison d’un interruption d’instanceSpot (p. 115).

Si le processus a reçu un rappel onProcessTerminate(), la valeur renvoyée est l'heure de résiliationestimée en heure Posix en secondes. Si le processus n’a pas reçu de onProcessTerminate() callback,un message d’erreur est renvoyé. En savoir plus sur l'arrêt d'un processus serveur (p. 49).

Syntax

AwsLongOutcome GetTerminationTime();

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

En cas de réussite, renvoie l’heure de fin sous la forme d’un AwsLongOutcome objet. La valeur est soitle temps de terminaison en secondes de période. Si aucune heure de fin n’est disponible, renvoie unmessage d’erreur.

Example

Aws::GameLift::AwsLongOutcome TermTimeOutcome = Aws::GameLift::Server::GetTerminationTime();

InitSDK()

Initialise le kit SDK GameLift. Cette méthode doit être appelée au lancement, avant l'exécution de touteautre initialisation liée à GameLift.

Syntax

InitSDKOutcome InitSDK();

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

En cas de réussite, un objet InitSdkOutcome est renvoyé, indiquant que le processus serveur est prêt àappeler ProcessReady() (p. 291).

Version290

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

Example

Aws::GameLift::Server::InitSDKOutcome initOutcome = Aws::GameLift::Server::InitSDK();

ProcessEnding()

Informe le service GameLift que le processus serveur est en cours d'arrêt. Cette méthode doit être appeléeaprès toutes les autres tâches de nettoyage, y compris l'arrêt de toutes les sessions de jeu actives.Cette méthode doit quitter avec un code de sortie 0 ; un code de sortie différent de 0 génère un messaged'événement indiquant que le processus ne s'est pas fermé correctement.

Syntax

GenericOutcome ProcessEnding();

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Example

Aws::GameLift::GenericOutcome outcome = Aws::GameLift::Server::ProcessEnding();

ProcessReady()

Informe le service GameLift que le processus serveur est prêt à héberger des sessions de jeu. Appelezcette méthode après avoir réussi à appeler InitSDK() (p. 290) et la réalisation des tâches de configurationrequises avant que le processus serveur puisse héberger une session de jeu. Cette méthode ne doit êtreappelée qu’une seule fois par processus.

Cet appel est synchrone. Pour effectuer un appel asynchrone, utilisez ProcessReadyAsync() (p. 292).(Pour plus d'informations, consultez Initialiser le processus serveur (p. 46).)

Syntax

GenericOutcome ProcessReady( const Aws::GameLift::Server::ProcessParameters &processParameters);

Parameters

processParameters

Objet ProcessParameters (p. 299) communiquant les informations suivantes relatives au processusserveur :• Noms des méthodes de rappel, mises en œuvre dans le code du serveur de jeux, que le service

GameLift appelle pour communiquer avec le processus serveur.• Numéro de port sur lequel le processus serveur écoute.• Chemin vers les fichiers spécifiques à une session de jeu que vous voulez qu'GameLift capture et

stocke.

Version291

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

 : obligatoire.  : oui

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Example

Cet exemple illustre les implémentations de la fonction d'appel et de rappel ProcessReady() (p. 291).

// 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()

Informe le service GameLift que le processus serveur est prêt à héberger des sessions de jeu. Cetteméthode doit être appelée une fois que le processus serveur est prêt à héberger une session de jeu.Les paramètres spécifient les noms des fonctions de rappel qu'GameLift doit appeler dans certainescirconstances. Le code du serveur de jeux doit implémenter ces fonctions.

Cet appel est asynchrone. Pour effectuer un appel synchrone, utilisez ProcessReady() (p. 291). (Pourplus d'informations, consultez Initialiser le processus serveur (p. 46).)

Version292

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

Syntax

GenericOutcomeCallable ProcessReadyAsync( const Aws::GameLift::Server::ProcessParameters &processParameters);

Parameters

processParameters

Objet ProcessParameters (p. 299) communiquant les informations suivantes relatives au processusserveur :• Noms des méthodes de rappel, mises en œuvre dans le code du serveur de jeux, que le service

GameLift appelle pour communiquer avec le processus serveur.• Numéro de port sur lequel le processus serveur écoute.• Chemin vers les fichiers spécifiques à une session de jeu que vous voulez qu'GameLift capture et

stocke.

 : obligatoire.  : oui

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Example

// 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();}

bool onHealthCheck()

Version293

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

{ // perform health evaluation and complete within 60 seconds return health;}

RemovePlayerSession()

Informe le service GameLift qu'un joueur avec l'ID de session de joueur spécifié s'est déconnecté duprocessus serveur. En réponse, GameLift fait passer l'emplacement de joueur à l'état disponible, ce qui luipermet d'être attribué à un nouveau joueur.

Syntax

GenericOutcome RemovePlayerSession( const std::string& playerSessionId);

Parameters

playerSessionId

ID unique émis par le service Amazon GameLift en réponse à un appel d'API du kit AWS SDKAmazon GameLiftCreatePlayerSession. Le client de jeu fait référence à cet ID lors de la connexion auprocessus serveur.

Type : std::string

Requis : non

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Exemple

Aws::GameLift::GenericOutcome disconnectOutcome = Aws::GameLift::Server::RemovePlayerSession(playerSessionId);

StartMatchBackfill

Envoie une demande de recherche de nouveaux joueurs pour des emplacements ouverts dans unesession de jeu créée avec FlexMatch. Voir aussi l'action AWS SDK StartMatchBackfill(). Avec cette action,les requêtes de renvoi de correspondance peuvent être initiées par processus de serveur de jeu quihéberge la session de jeu. Découvrez la fonction de renvoi FlexMatch dans Renvoi de jeux existantsavecFlexMatch (p. 85).

Cette action est asynchrone. Si de nouveaux joueurs sont correctement mis en correspondance,le GameLift fournit des données de matchmaker mises à jour en appelant la fonction de rappelOnUpdateGameSession().

Un processus de serveur ne peut comporter qu'une seule requête de renvoi de correspondance à la fois.Pour envoyer une nouvelle requête, appelez d'abord StopMatchBackfill() (p. 295) pour annuler la requêted'origine.

Syntax

StartMatchBackfillOutcome StartMatchBackfill (

Version294

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

const Aws::GameLift::Server::Model::StartMatchBackfillRequest &startBackfillRequest);

Parameters

StartMatchBackfillRequest

Objet StartMatchBackfillRequest (p. 300) qui communique les informations suivantes :• ID de ticket à attribuer à la requête de renvoi. Cette information est facultative ; si aucun ID n'est

fourni, GameLift en génère automatiquement un.• Matchmaker auquel envoyer la requête. L'ARN de configuration complet est obligatoire. Cette valeur

peut être acquise à partir des données matchmaker de la session de jeu.• ID de la session de jeu en cours de renvoi.• Données de correspondance disponibles pour les joueurs actuels de la session de jeu.

 : obligatoire.  : oui

Valeur renvoyée

Renvoie un objet StartMatchBackfillOutcome avec le ticket de renvoi de mise en relation ou unéchec avec un message d'erreur. Le statut du ticket peut être suivi à l'aide de l'action AWS SDKDescribeMatchmaking().

Exemple

// 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()

Annule une requête de renvoi de correspondance active qui a été créée avec StartMatchBackfill (p. 294).Voir aussi l'action AWS SDK StopMatchmaking(). Découvrez la fonction de renvoi FlexMatch dans Renvoide jeux existants avecFlexMatch (p. 85).

Syntax

GenericOutcome StopMatchBackfill (

Version295

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

const Aws::GameLift::Server::Model::StopMatchBackfillRequest &stopBackfillRequest);

Parameters

StopMatchBackfillRequest

Objet StopMatchBackfillRequest (p. 301) qui identifie le ticket de correspondance à annuler :• Identifiant de ticket attribué à la requête de renvoi en cours d'annulation• matchmaker auquel a été envoyée la requête• session de jeu associée à la requête de renvoi

 : obligatoire.  : oui

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Exemple

// 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()

Cette méthode est obsolète avec version 4.0.1. Au lieu de cela, le processus serveur doit appelerProcessEnding() (p. 291) après la fin d’une session de jeu.

Avertit le GameLift que le processus serveur a terminé la session de jeu actuelle. Cette action est appeléelorsque le processus serveur reste actif et prêt à héberger une nouvelle session de jeu. Elle ne doit êtreappelée qu’une fois la procédure de fin de session de jeu terminée, car elle signale à GameLift que leprocessus serveur est immédiatement disponible pour héberger une nouvelle session de jeu.

Cette action n’est pas appelée si le processus serveur est arrêté après l’arrêt de la session de jeu. Au lieude cela, appelez ProcessEnding() (p. 291) pour indiquer que la session de jeu et le processus serveur seterminent tous les deux.

Syntax

GenericOutcome TerminateGameSession();

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Version296

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

UpdatePlayerSessionCreationPolicy()Met à jour la capacité de la session de jeu à accepter de nouvelles sessions de joueur. Une session dejeu peut être définie pour accepter ou refuser toutes les nouvelles sessions joueur. Voir aussi l'action AWSSDK UpdateGameSession().

Syntax

GenericOutcome UpdatePlayerSessionCreationPolicy( Aws::GameLift::Model::PlayerSessionCreationPolicy newPlayerSessionPolicy);

Parameters

newPlayerSessionPolicy

Valeur de chaîne indiquant si la session de jeu accepte ou non de nouveaux joueurs.

Type: Aws : GameLift : Modèle : PolitiqueCréationSessionJoueur énumération. Les valeurs validessont les suivantes :• ACCEPT_ALL – Accepter toutes les nouvelles sessions de joueur.• DENY_ALL – Refuser toutes les nouvelles sessions de joueur.

 : obligatoire.  : oui

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Example

Cet exemple définit la stratégie de participation de la session de jeu actuelle de manière à ce que tous lesjoueurs soient acceptés.

Aws::GameLift::GenericOutcome outcome = Aws::GameLift::Server::UpdatePlayerSessionCreationPolicy(Aws::GameLift::Model::PlayerSessionCreationPolicy::ACCEPT_ALL);

Référence d'API GameLift Server pour C++ Types de donnéesCette référence d'API de serveur C++ GameLift peut vous aider à préparer votre jeu multijoueur pourune utilisation avec GameLift. Pour plus d'informations sur le processus d'intégration, consultez AjouterGameLift vers votre serveur de jeux (p. 46).

Cette API est définie dans GameLiftServerAPI.h, LogParameters.h et ProcessParameters.h.

• Actions: (p. 286)• Types de données

DescribePlayerSessionsRequestCe type de données est utilisé pour spécifier les sessions de joueur à récupérer. Vous pouvez l'utilisercomme suit :

• Fournissez un PlayerSessionId pour demander une session de joueur spécifique.• Fournissez un GameSessionId pour demander toutes les sessions de joueur de la session de jeu

spécifiée.

Version297

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

• Fournissez un PlayerId pour demander toutes les sessions de joueur du joueur spécifié.

Pour les volumes importants de sessions de joueur, utilisez les paramètres de pagination pour récupérerles résultats en tant que blocs séquentiels.

Contents

GameSessionId

Identifiant de session de jeu unique. Utilisez ce paramètre pour demander toutes les sessionsde joueur pour la session de jeu spécifiée. Le format de l'ID de session de jeu est le suivant : .arn:aws:gamelift:<region>::gamesession/fleet-<fleet ID>/<ID string>. La valeurde <ID string> est une chaîne d’ID personnalisée ou (si une chaîne a été spécifiée lors de la créationde la session de jeu) une chaîne générée.

Type. String (chaîne)

 : obligatoire. Non.Limite

Nombre maximum de résultats à renvoyer. Utilisez ce paramètre avec NextToken pour obtenir lesrésultats sous la forme d'un ensemble de pages séquentielles. Si un ID de session de joueur estspécifié, ce paramètre est ignoré.

Type. Integer

 : obligatoire. Non.NextToken

Jeton indiquant le début de la prochaine page séquentielle de résultats. Utilisez le jeton qui est renvoyépar un appel précédent à cette action. Pour spécifier le début de l'ensemble de résultats, ne spécifiezaucune valeur. Si un ID de session de joueur est spécifié, ce paramètre est ignoré.

Type. String (chaîne)

 : obligatoire. Non.PlayerId

Identifiant unique pour un joueur. Les ID de joueur sont définis par le développeur. Veuillez consulterGénération d'ID de joueur (p. 57).

Type. String (chaîne)

 : obligatoire. Non.PlayerSessionId

Identifiant unique d'une session de joueur.

Type. String (chaîne)

 : obligatoire. Non.PlayerSessionStatusFilter

État de session de joueur pour filtrer les résultats. Les états de session de joueur possibles sont lessuivants :• RESERVED - La demande de session de joueur a été reçue, mais le joueur ne s'est pas encore

connecté au processus serveur et/ou n'a pas encore été validé.• ACTIVE - Le joueur a été validé par le processus serveur et est actuellement connecté.• COMPLETED - La connexion du joueur a été abandonnée.

Version298

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

• TIMEDOUT - Une demande de session de joueur a été reçue, mais le joueur ne s'est pas connectéet/ou n'a pas été validé avant l'expiration du délai (60 secondes).

Type. String (chaîne)

 : obligatoire. Non.

LogParametersCe type de données est utilisé pour identifier les fichiers générés au cours d'une session de jeu quevous souhaitez qu'GameLift charge et stocke lorsque la session de jeu se termine. Ces informations sontcommuniquées au service GameLift dans un appel ProcessReady() (p. 291).

Contents

logPaths

Chemins de répertoire d'accès aux fichiers journaux du serveur de jeux que vous souhaitezqu'GameLift stocke pour y accéder ultérieurement. Ces fichiers sont générés au cours de chaquesession de jeu. Les chemins et noms des fichiers sont définis dans votre serveur de jeux et stockésdans le répertoire racine de génération de jeu. Par exemple, si la version de génération de votre jeustocke les journaux de session de jeu suivant un chemin tel que MyGame\sessionlogs\, le chemind'accès aux journaux est c:\game\MyGame\sessionLogs (sur une instance Windows) ou /local/game/MyGame/sessionLogs (sur une instance Linux).

Type : std:vector<std::string>

 : obligatoire. Non.

ProcessParametersCe type de données contient l'ensemble des paramètres envoyés au service GameLift dans un appelProcessReady() (p. 291).

Contents

port

Numéro de port sur lequel le processus serveur écoute les nouvelles connexions de joueur. La valeurdoit être comprise dans la plage de ports configurée pour toutes les flottes déployant cette version degénération du serveur de jeux. Ce numéro de port est inclus dans les objets de session de jeu et desession de joueur, que les sessions de jeu utilisent pour se connecter à un processus serveur.

Type. Integer

 : obligatoire.  : ouilogParameters

Objet comportant une liste de chemins de répertoires vers les fichiers journaux de sessions de jeu.

Type. Aws : LiftJeu : Serveur :LogParameters (p. 299)

 : obligatoire. Non.onStartGameSession

Nom de la fonction de rappel que le GameLift Le service appelle pour activer une nouvelle session dejeu. GameLift appelle cette fonction en réponse à la demande du client CréerSessionJeu. La fonctionde rappel transmet un objet GameSession (défini dans le manuel Référence API du service GameLift).

Version299

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

Type: const std::function<void(Aws::GameLift::Model::GameSession)>onStartGameSession

 : obligatoire.  : ouionProcessTerminate

Nom de la fonction de rappel que le GameLift Le service appelle pour forcer le processus serveurà arrêter. Après avoir appelé cette fonction, GameLift patiente cinq minutes afin que le processusserveur s'arrête et réponde avec un appel ProcessEnding() (p. 291). Si aucune réponse n'est reçue,le processus serveur est arrêté.

Type: std::function<void()> onProcessTerminate

 : obligatoire. Non.onHealthCheck

Nom de la fonction de rappel que le GameLift pour demander un rapport d’état de santé au processusserveur. GameLift appelle cette fonction toutes les 60 secondes. Après l'appel de cette fonction,GameLift attend une réponse pendant 60 secondes, et si aucune réponse n'est reçue, enregistre leprocessus serveur comme n'étant pas sain.

Type: std::function<bool()> onHealthCheck

 : obligatoire. Non.onUpdateGameSession

Nom de la fonction de rappel que le GameLift Le service appelle pour transmettre un objet desession de jeu mis à jour au processus serveur. GameLift appelle cette fonction lorsqu’un remblaicorrespondant (p. 85) a été traitée afin de fournir des données mises à jour sur le matchmaker. Iltransmet un objet GameSession, une mise à jour d'état (updateReason), ainsi que l'identifiant deticket de renvoi de mise en relation.

Type: std::function<void(Aws::GameLift::Server::Model::UpdateGameSession)>onUpdateGameSession

 : obligatoire. Non.

StartMatchBackfillRequestCe type de données est utilisé pour envoyer une requête de renvoi de correspondance. Les informationssont communiquées au service GameLift dans un appel StartMatchBackfill (p. 294).

Contents

GameSessionArn

Identifiant de session de jeu unique. L'action d'API GetGameSessionId() (p. 288) renvoie l'identifiantau format ARN.

Type. String (chaîne)

 : obligatoire.  : ouiMatchmakingConfigurationArn

Identifiant unique, sous la forme d'un ARN, pour le matchmaker à utiliser pour cette requête. Pourtrouver le matchmaker qui a été utilisé pour créer la session de jeu d'origine, recherchez dans l'objetde session de jeu, dans la propriété de données de matchmaker. Découvrez les données matchmakerdans Utiliser des données de matchmaker (p. 84).

Type. String (chaîne)

Version300

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

 : obligatoire.  : ouiJoueurs

Ensemble de données représentant tous les joueurs qui sont actuellement dans la session de jeu. Lematchmaker utilise ces informations pour rechercher de nouveaux joueurs qui constituent de bonnescorrespondances pour les joueurs actuels. Pour une description du format d'objet Joueur, consultez lemanuel Amazon GameLift API Reference Guide. Pour trouver des attributs de joueur, des identifiantset des affectations d'équipe, recherchez dans l'objet de session de jeu, dans la propriété des donnéesde matchmaker. Si une latence est utilisée par le matchmaker, collectez la latence mise à jour pour larégion actuelle et incluez-la dans les données de chaque joueur.

Type : std:vector<Player>

 : obligatoire.  : ouiTicketId

Identifiant unique pour une correspondance ou un ticket de requête de renvoi de correspondance. Siaucune valeur n'est fournie ici, Amazon GameLift en génère une sous la forme d'un UUID. Utilisez cetidentifiant pour suivre l'état du ticket de renvoi de correspondance ou annuler la requête si nécessaire.

Type. String (chaîne)

 : obligatoire. Non.

StopMatchBackfillRequestCe type de données est utilisé pour annuler une demande de renvoi de correspondance. Les informationssont communiquées au service GameLift dans un appel StopMatchBackfill() (p. 295).

Contents

GameSessionArn

Identifiant de session de jeu unique associé à la requête en cours d'annulation.

Type. String (chaîne)

 : obligatoire.  : ouiMatchmakingConfigurationArn

Identifiant unique du matchmaker auquel cette requête a été envoyée.

Type. String (chaîne)

 : obligatoire.  : ouiTicketId

Identifiant unique d'un ticket de requête de correspondance à annuler.

Type. String (chaîne)

 : obligatoire.  : oui

Référence d'API GameLift Server pour C++Cette Référence API GameLift Server C# peut vous aider à préparer votre jeu multijoueur pour uneutilisation avec GameLift. Pour plus d'informations sur le processus d'intégration, consultez AjouterGameLift vers votre serveur de jeux (p. 46).

Version301

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

Cette API est définie dans GameLiftServerAPI.cs, LogParameters.cs et ProcessParameters.cs.

• Actions: (p. 302)• Types de données (p. 311)

GameLift Référence de l’API du serveur (C#) : Actions:Cette Référence API GameLift Server C# peut vous aider à préparer votre jeu multijoueur pour uneutilisation avec GameLift. Pour plus d'informations sur le processus d'intégration, consultez AjouterGameLift vers votre serveur de jeux (p. 46).

Cette API est définie dans GameLiftServerAPI.cs, LogParameters.cs et ProcessParameters.cs.

• Actions:• Type de données (p. 311)

AcceptPlayerSession()

Informe le service GameLift qu'un joueur avec l'ID de session de joueur spécifié s'est connecté auprocessus serveur et attend une validation. GameLift vérifie que l'ID de session de joueur est valide, c'est-à-dire que l'ID de joueur a réservé un emplacement de joueur dans la session de jeu. Une fois la validationeffectuée, GameLift fait passer l'emplacement de joueur de l'état RESERVED à ACTIVE.

Syntax

GenericOutcome AcceptPlayerSession(String playerSessionId)

Parameters

playerSessionId

ID unique émis par GameLift lorsqu'une nouvelle session de joueur est créée. L'ID de session dejoueur est spécifié dans un objet PlayerSession qui est renvoyé en réponse à un appel du client auxactions de l'API AWS SDK Amazon GameLift StartGameSessionPlacement, CreateGameSession, DescribeGameSessionPlacement ou DescribePlayerSessions.

Type : chaîne

Requis : non

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Example

Cet exemple illustre une fonction pour le traitement d'une demande de connexion, y compris la validation etle rejet des ID de session joueur non valides.

void ReceiveConnectingPlayerSessionID (Connection connection, String playerSessionId){ var acceptPlayerSessionOutcome = GameLiftServerAPI.AcceptPlayerSession(playerSessionId); if(acceptPlayerSessionOutcome.Success) { connectionToSessionMap.emplace(connection, playerSessionId);

Version302

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

connection.Accept(); } else { connection.Reject(acceptPlayerSessionOutcome.Error.ErrorMessage); } }

ActivateGameSession()

Informe le service GameLift que le processus serveur a activé une session de jeu et est maintenant prêtà recevoir des connexions de joueur. Cette action doit être appelée dans le cadre de la fonction de rappelonStartGameSession(), une fois que l'initialisation de toutes les sessions de jeu est terminée.

Syntax

GenericOutcome ActivateGameSession()

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Example

Cet exemple illustre l'appel de ActivateGameSession() dans le cadre de la fonction déléguéeonStartGameSession().

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()

Récupère les données de session de joueur, y compris les paramètres, les métadonnées de session et lesdonnées de joueur. Utilisez cette action pour obtenir des informations pour une seule session de joueur,pour toutes les sessions de joueur d'une session de jeu ou pour toutes les sessions de joueur associées àun seul ID de joueur.

Syntax

DescribePlayerSessionsOutcome DescribePlayerSessions(DescribePlayerSessionsRequest describePlayerSessionsRequest)

Parameters

describePlayerSessionsRequest

Objet DescribePlayerSessionsRequest (p. 312) décrivant les sessions de joueur à récupérer.

 : obligatoire.  : oui

Version303

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

Valeur renvoyée

En cas de réussite, renvoie un objet DescribePlayerSessionsOutcome qui contient un ensembled'objets de session de joueur correspondant aux paramètres de la demande. La structure des objets desessions de joueur est identique au type de données de l'API GameLift du AWS SDK PlayerSession.

Example

Cet exemple illustre une demande de toutes les sessions de joueur activement connectées à une sessionde jeu spécifiée. Si vous omettez NextToken et définissez la valeur de Limit sur 10, GameLift renverra les10 premiers enregistrements de sessions de joueur qui correspondent à la demande.

// Set request parameters var describePlayerSessionsRequest = new Aws.GameLift.Server.Model.DescribePlayerSessionsRequest(){ GameSessionId = GameLiftServerAPI.GetGameSessionId().Result, //gets the ID for the current game session Limit = 10, PlayerSessionStatusFilter = PlayerSessionStatusMapper.GetNameForPlayerSessionStatus(PlayerSessionStatus.ACTIVE)}; // Call DescribePlayerSessionsAws::GameLift::DescribePlayerSessionsOutcome playerSessionsOutcome = Aws::GameLift::Server::Model::DescribePlayerSessions(describePlayerSessionRequest);

GetGameSessionId()

Extrait l'ID de la session de jeu actuellement hébergée par le processus serveur, si ce dernier est actif.

Syntax

AwsStringOutcome GetGameSessionId()

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

En cas de réussite, renvoie l'ID de session de jeu en tant qu'objet AwsStringOutcome. En cas d'échec,renvoie un message d'erreur.

Example

var getGameSessionIdOutcome = GameLiftServerAPI.GetGameSessionId();

GetInstanceCertificate ()

Récupère l'emplacement de fichier d'un certificat TLS codé pem qui est associé au parc et à ses instances.Ce certificat est généré lorsqu'une nouvelle flotte est créée avec la configuration de certificat définie surGENERATED. Utilisez ce certificat pour établir une connexion sécurisée avec un client de jeu et pourchiffrer la communication client/serveur.

Syntax

GetInstanceCertificateOutcome GetInstanceCertificate();

Version304

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

En cas de réussite, renvoie un objet GetInstanceCertificateOutcome contenant l'emplacementdu fichier de certificat TLS de la flotte, qui est stocké sur l'instance. En cas d'échec, renvoie un messaged'erreur.

Example

var getInstanceCertificateOutcome = GameLiftServerAPI.GetInstanceCertificate();

GetSdkVersion()Renvoie le numéro de version actuel du kit SDK intégré dans le processus serveur.

Syntax

AwsStringOutcome GetSdkVersion()

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

En cas de réussite, renvoie la version actuelle du kit SDK en tant qu'objet AwsStringOutcome. La chaînerenvoyée inclut uniquement le numéro de version (par ex. « 3,15 pouces »). En cas d'échec, renvoie unmessage d'erreur.

Example

var getSdkVersionOutcome = GameLiftServerAPI.GetSdkVersion();

GetTerminationTime()Renvoie l'heure d'arrêt planifiée pour un processus serveur, si une heure de résiliation est disponible. Unprocessus serveur effectue cette action après avoir reçu un onProcessTerminate() rappel depuisle GameLift du service après-vente. GameLift peut appeler onProcessTerminate() pour les raisonssuivantes : (1) en raison d’un mauvais état de santé (le processus serveur a signalé un état de santé duport ou n’a pas répondu à GameLift, (2) lors de la mise hors service de l’instance lors d’un événement dediminution de charge, ou (3) lorsqu’une instance est mise hors service en raison d’un interruption d’instanceSpot (p. 115).

Si le processus a reçu un rappel onProcessTerminate(), la valeur renvoyée est l'heure de résiliationestimée en heure Posix en secondes. Si le processus n’a pas reçu de onProcessTerminate() callback,un message d’erreur est renvoyé. En savoir plus sur l'arrêt d'un processus serveur (p. 49).

Syntax

AwsDateTimeOutcome GetTerminationTime()

Parameters

Cette action n'a aucun paramètre.

Version305

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

Valeur renvoyée

En cas de réussite, renvoie l’heure de fin sous la forme d’un AwsDateTimeOutcome objet. La valeur estsoit le temps de terminaison en secondes de période. Si aucune heure de fin n’est disponible, renvoie unmessage d’erreur.

Example

var getTerminationTimeOutcome = GameLiftServerAPI.GetTerminationTime();

InitSDK()

Initialise le kit SDK GameLift. Cette méthode doit être appelée au lancement, avant l'exécution de touteautre initialisation liée à GameLift.

Syntax

InitSDKOutcome InitSDK()

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

En cas de réussite, un objet InitSdkOutcome est renvoyé, indiquant que le processus serveur est prêt àappeler ProcessReady() (p. 307).

Example

var initSDKOutcome = GameLiftServerAPI.InitSDK();

ProcessEnding()

Informe le service GameLift que le processus serveur est en cours d'arrêt. Cette méthode doit être appeléeaprès toutes les autres tâches de nettoyage, y compris l'arrêt de toutes les sessions de jeu actives.Cette méthode doit quitter avec un code de sortie 0 ; un code de sortie différent de 0 génère un messaged'événement indiquant que le processus ne s'est pas fermé correctement.

Syntax

GenericOutcome ProcessEnding()

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Example

var processEndingOutcome = GameLiftServerAPI.ProcessEnding();

Version306

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

ProcessReady()Informe le service GameLift que le processus serveur est prêt à héberger des sessions de jeu. Appelezcette méthode après avoir réussi à appeler InitSDK() (p. 306) et la réalisation des tâches de configurationrequises avant que le processus serveur puisse héberger une session de jeu. Cette méthode ne doit êtreappelée qu’une seule fois par processus.

Syntax

GenericOutcome ProcessReady(ProcessParameters processParameters)

Parameters

processParameters

Objet ProcessParameters (p. 313) communiquant les informations suivantes relatives au processusserveur :• Noms des méthodes de rappel, mises en œuvre dans le code du serveur de jeux, que le service

GameLift appelle pour communiquer avec le processus serveur.• Numéro de port sur lequel le processus serveur écoute.• Chemin vers les fichiers spécifiques à une session de jeu que vous voulez qu'GameLift capture et

stocke.

 : obligatoire.  : oui

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Example

Cet exemple illustre les implémentations de l'appel ProcessReady() (p. 307) et de la fonction déléguée.

// Set parameters and call ProcessReadyvar 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(){

Version307

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

// 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;}

RemovePlayerSession()Informe le service GameLift qu'un joueur avec l'ID de session de joueur spécifié s'est déconnecté duprocessus serveur. En réponse, GameLift fait passer l'emplacement de joueur à l'état disponible, ce qui luipermet d'être attribué à un nouveau joueur.

Syntax

GenericOutcome RemovePlayerSession(String playerSessionId)

Parameters

playerSessionId

ID unique émis par GameLift lorsqu'une nouvelle session de joueur est créée. L'ID de session dejoueur est spécifié dans un objet PlayerSession qui est renvoyé en réponse à un appel du client auxactions de l'API AWS SDK Amazon GameLift StartGameSessionPlacement, CreateGameSession, DescribeGameSessionPlacement ou DescribePlayerSessions.

Type : chaîne

Requis : non

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Exemple

Aws::GameLift::GenericOutcome disconnectOutcome = Aws::GameLift::Server::RemovePlayerSession(playerSessionId);

StartMatchBackfillEnvoie une demande de recherche de nouveaux joueurs pour des emplacements ouverts dans unesession de jeu créée avec FlexMatch. Voir aussi l'action AWS SDK StartMatchBackfill(). Avec cette action,les requêtes de renvoi de correspondance peuvent être initiées par processus de serveur de jeu quihéberge la session de jeu. Découvrez la fonction de renvoi FlexMatch dans Renvoi de jeux existantsavecFlexMatch (p. 85).

Cette action est asynchrone. Si de nouveaux joueurs sont mis en relation, le service GameLift fournit lesdonnées du matchmaker mises à jour à l'aide de la fonction de renvoi OnUpdateGameSession().

Un processus de serveur ne peut comporter qu'une seule requête de renvoi de correspondance à la fois.Pour envoyer une nouvelle requête, appelez d'abord StopMatchBackfill() (p. 309) pour annuler la requêted'origine.

Version308

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

Syntax

StartMatchBackfillOutcome StartMatchBackfill (StartMatchBackfillRequest startBackfillRequest);

Parameters

StartMatchBackfillRequest

Objet StartMatchBackfillRequest (p. 314) qui communique les informations suivantes :• ID de ticket à attribuer à la requête de renvoi. Cette information est facultative ; si aucun ID n'est

fourni, GameLift en génère automatiquement un.• Matchmaker auquel envoyer la requête. L'ARN de configuration complet est obligatoire. Cette valeur

peut être acquise à partir des données matchmaker de la session de jeu.• ID de la session de jeu en cours de renvoi.• Données de correspondance disponibles pour les joueurs actuels de la session de jeu.

 : obligatoire.  : oui

Valeur renvoyée

Renvoie un objet StartMatchBackfillOutcome avec l'identifiant de ticket de renvoi de correspondance ou unéchec avec un message d'erreur.

Exemple

// Build a backfill requestvar 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()

Annule une requête de renvoi de correspondance active qui a été créée avec StartMatchBackfill (p. 308).Voir aussi l'action AWS SDK StopMatchmaking(). Découvrez la fonction de renvoi FlexMatch dans Renvoide jeux existants avecFlexMatch (p. 85).

Version309

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

Syntax

GenericOutcome StopMatchBackfill (StopMatchBackfillRequest stopBackfillRequest);

Parameters

StopMatchBackfillRequest

Objet StopMatchBackfillRequest (p. 315) qui identifie le ticket de correspondance à annuler :• Identifiant de ticket attribué à la requête de renvoi en cours d'annulation• matchmaker auquel a été envoyée la requête• session de jeu associée à la requête de renvoi

 : obligatoire.  : oui

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Exemple

// Set backfill stop request parameters

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()

Cette méthode est obsolète avec version 4.0.1. Au lieu de cela, le processus serveur doit appelerProcessEnding() (p. 306) après la fin d’une session de jeu.

Avertit le GameLift que le processus serveur a terminé la session de jeu actuelle. Cette action est appeléelorsque le processus serveur reste actif et prêt à héberger une nouvelle session de jeu. Elle ne doit êtreappelée qu’une fois la procédure de fin de session de jeu terminée, car elle signale à GameLift que leprocessus serveur est immédiatement disponible pour héberger une nouvelle session de jeu.

Cette action n’est pas appelée si le processus serveur est arrêté après l’arrêt de la session de jeu. Au lieude cela, appelez ProcessEnding() (p. 306) pour indiquer que la session de jeu et le processus serveur seterminent tous les deux.

Syntax

GenericOutcome TerminateGameSession()

Parameters

Cette action n'a aucun paramètre.

Version310

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Example

Cet exemple illustre un processus de serveur à la fin d'une session de jeu.

// 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()

Met à jour la capacité de la session de jeu à accepter de nouvelles sessions de joueur. Une session de jeupeut être définie pour accepter ou refuser toutes les nouvelles sessions joueur. (Consultez aussi l'actionUpdateGameSession() dans le manuel Référence API GameLift Server).

Syntax

GenericOutcome UpdatePlayerSessionCreationPolicy(PlayerSessionCreationPolicy playerSessionPolicy)

Parameters

newPlayerSessionPolicy

Valeur de chaîne indiquant si la session de jeu accepte ou non de nouveaux joueurs.

Type. Politique de création de session de joueur énumération. Les valeurs valides sont les suivantes :• ACCEPT_ALL – Accepter toutes les nouvelles sessions de joueur.• DENY_ALL – Refuser toutes les nouvelles sessions de joueur.

 : obligatoire.  : oui

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Example

Cet exemple définit la stratégie de participation de la session de jeu actuelle de manière à ce que tous lesjoueurs soient acceptés.

var updatePlayerSessionCreationPolicyOutcomex = GameLiftServerAPI.UpdatePlayerSessionCreationPolicy(PlayerSessionCreationPolicy.ACCEPT_ALL);

Référence d'API GameLift Server pour C++ Types de donnéesCette Référence API GameLift Server C# peut vous aider à préparer votre jeu multijoueur pour uneutilisation avec GameLift. Pour plus d'informations sur le processus d'intégration, consultez AjouterGameLift vers votre serveur de jeux (p. 46).

Version311

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

Cette API est définie dans GameLiftServerAPI.cs, LogParameters.cs et ProcessParameters.cs.

• Actions: (p. 302)• Types de données

LogParametersCe type de données est utilisé pour identifier les fichiers générés au cours d'une session de jeu quevous souhaitez qu'GameLift charge et stocke lorsque la session de jeu se termine. Ces informations sontcommuniquées au service GameLift dans un appel ProcessReady() (p. 307).

Contents

logPaths

Liste des chemins de répertoire d'accès aux fichiers journaux du serveur de jeux que vous souhaitezqu'GameLift stocke pour y accéder ultérieurement. Ces fichiers sont générés par un processus serveurpendant chaque session de jeu ; les noms et les chemins des fichiers sont définis dans votre serveurde jeux et stockés dans le répertoire racine de la version de génération de jeu. Par exemple, si laversion de génération de votre jeu stocke les journaux de session de jeu suivant un chemin tel queMyGame\sessionlogs\, le chemin d'accès aux journaux est c:\game\MyGame\sessionLogs (surune instance Windows) ou /local/game/MyGame/sessionLogs (sur une instance Linux).

Type. Liste<Chaîne>

 : obligatoire. Non.

DescribePlayerSessionsRequestCe type de données est utilisé pour spécifier les sessions de joueur à récupérer. Il peut être utilisé dedifférentes manières : (1) fournir un PlayerSessionId pour demander une session de joueur spécifique ; (2)fournir un GameSessionId pour demander toutes les sessions de joueur dans la session de jeu spécifiée ;ou (3) fournir un PlayerId pour demander toutes les sessions pour le joueur spécifié. Pour les volumesimportants de sessions de joueur, utilisez les paramètres de pagination pour récupérer les résultats en tantque pages séquentielles.

Contents

GameSessionId

Identifiant de session de jeu unique. Utilisez ce paramètre pour demander toutes les sessionsde joueur pour la session de jeu spécifiée. Le format de l'ID de session de jeu est le suivant : .arn:aws:gamelift:<region>::gamesession/fleet-<fleet ID>/<ID string>. La valeurde <ID string> est soit une chaîne d’ID personnalisée (si une chaîne a été spécifiée lors de la créationde la session de jeu), soit une chaîne générée.

Type. String (chaîne)

 : obligatoire. Non.Limite

Nombre maximum de résultats à renvoyer. Utilisez ce paramètre avec NextToken pour obtenir lesrésultats sous la forme d'un ensemble de pages séquentielles. Si un ID de session de joueur estspécifié, ce paramètre est ignoré.

Type. Integer

 : obligatoire. Non.

Version312

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

NextToken

Jeton indiquant le début de la prochaine page séquentielle de résultats. Utilisez le jeton qui est renvoyépar un appel précédent à cette action. Pour spécifier le début de l'ensemble de résultats, ne spécifiezaucune valeur. Si un ID de session de joueur est spécifié, ce paramètre est ignoré.

Type. String (chaîne)

 : obligatoire. Non.PlayerId

Identifiant unique pour un joueur. Les ID de joueur sont définis par le développeur. Veuillez consulterGénération d'ID de joueur (p. 57).

Type. String (chaîne)

 : obligatoire. Non.PlayerSessionId

Identifiant unique d'une session de joueur.

Type. String (chaîne)

 : obligatoire. Non.PlayerSessionStatusFilter

État de session de joueur pour filtrer les résultats. Les états de session de joueur possibles sont lessuivants :• RESERVED - La demande de session de joueur a été reçue, mais le joueur ne s'est pas encore

connecté au processus serveur et/ou n'a pas encore été validé.• ACTIVE - Le joueur a été validé par le processus serveur et est actuellement connecté.• COMPLETED - La connexion du joueur a été abandonnée.• TIMEDOUT - Une demande de session de joueur a été reçue, mais le joueur ne s'est pas connecté

et/ou n'a pas été validé avant l'expiration du délai (60 secondes).

Type. String (chaîne)

 : obligatoire. Non.

ProcessParametersCe type de données contient l'ensemble des paramètres envoyés au service GameLift dans un appelProcessReady() (p. 307).

Contents

port

Numéro de port sur lequel le processus serveur écoute les nouvelles connexions de joueur. La valeurdoit être comprise dans la plage de ports configurée pour toutes les flottes déployant cette version degénération du serveur de jeux. Ce numéro de port est inclus dans les objets de session de jeu et desession de joueur, que les sessions de jeu utilisent pour se connecter à un processus serveur.

Type. Integer

 : obligatoire.  : ouilogParameters

Objet comportant une liste de chemins de répertoires vers les fichiers journaux de sessions de jeu.

Version313

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

Type: Aws::GameLift::Server::LogParameters (p. 312)

 : obligatoire.  : ouionStartGameSession

Nom de la fonction de rappel que le GameLift Le service appelle pour activer une nouvelle session dejeu. GameLift appelle cette fonction en réponse à la demande du client CréerSessionJeu. La fonctionde rappel prend un objet GameSession (défini dans le manuel Référence API GameLift Server).

Type: void OnStartGameSessionDelegate(GameSession gameSession)

 : obligatoire.  : ouionProcessTerminate

Nom de la fonction de rappel que le GameLift Le service appelle pour forcer le processus serveur àarrêter. Après l'appel de cette fonction, GameLift patiente cinq minutes afin que le processus serveurs'arrête et réponde avec un appel ProcessEnding() (p. 306) avant d'arrêter le processus serveur.

Type: void OnProcessTerminateDelegate()

 : obligatoire.  : ouionHealthCheck

Nom de la fonction de rappel que le GameLift pour demander un rapport d’état de santé au processusserveur. GameLift appelle cette fonction toutes les 60 secondes. Après l'appel de cette fonction,GameLift attend une réponse pendant 60 secondes, et si aucune réponse n'est reçue, enregistre leprocessus serveur comme n'étant pas sain.

Type: bool OnHealthCheckDelegate()

 : obligatoire.  : ouionUpdateGameSession

Nom de la fonction de rappel que le GameLift Le service appelle pour transmettre un objet desession de jeu mis à jour au processus serveur. GameLift appelle cette fonction lorsqu’un remblaicorrespondant (p. 85) a été traitée afin de fournir des données mises à jour sur le matchmaker. Iltransmet un objet GameSession, une mise à jour d'état (updateReason), ainsi que l'identifiant deticket de renvoi de mise en relation.

Type: void OnUpdateGameSessionDelegate ( UpdateGameSessionupdateGameSession )

 : obligatoire. Non.

StartMatchBackfillRequestCe type de données est utilisé pour envoyer une requête de renvoi de correspondance. Les informationssont communiquées au service GameLift dans un appel StartMatchBackfill (p. 308).

Contents

GameSessionArn

Identifiant de session de jeu unique. L'action d'API GetGameSessionId() (p. 304) renvoie l'identifiantau format ARN.

Type. String (chaîne)

 : obligatoire.  : oui

Version314

Amazon GameLift Manuel du développeurRéférence d'API de serveur pour C++

MatchmakingConfigurationArn

Identifiant unique, sous la forme d'un ARN, pour le matchmaker à utiliser pour cette requête. Pourtrouver le matchmaker qui a été utilisé pour créer la session de jeu d'origine, recherchez dans l'objetde session de jeu, dans la propriété de données de matchmaker. Découvrez les données matchmakerdans Utiliser des données de matchmaker (p. 84).

Type. String (chaîne)

 : obligatoire.  : ouiJoueurs

Ensemble de données représentant tous les joueurs qui sont actuellement dans la session de jeu. Lematchmaker utilise ces informations pour rechercher de nouveaux joueurs qui constituent de bonnescorrespondances pour les joueurs actuels. Pour une description du format d'objet Joueur, consultez lemanuel Amazon GameLift API Reference Guide. Pour trouver des attributs de joueur, des identifiantset des affectations d'équipe, recherchez dans l'objet de session de jeu, dans la propriété des donnéesde matchmaker. Si une latence est utilisée par le matchmaker, collectez la latence mise à jour pour larégion actuelle et incluez-la dans les données de chaque joueur.

Type. Joueur[ ]

 : obligatoire.  : ouiTicketId

Identifiant unique pour une correspondance ou un ticket de requête de renvoi de correspondance. Siaucune valeur n'est fournie ici, Amazon GameLift en génère une sous la forme d'un UUID. Utilisez cetidentifiant pour suivre l'état du ticket de renvoi de correspondance ou annuler la requête si nécessaire.

Type. String (chaîne)

 : obligatoire. Non.

StopMatchBackfillRequestCe type de données est utilisé pour annuler une demande de renvoi de correspondance. Les informationssont communiquées au service GameLift dans un appel StopMatchBackfill() (p. 309).

Contents

GameSessionArn

Identifiant de session de jeu unique associé à la requête en cours d'annulation.

Type. String (chaîne)

 : obligatoire.  : ouiMatchmakingConfigurationArn

Identifiant unique du matchmaker auquel cette requête a été envoyée.

Type. String (chaîne)

 : obligatoire.  : ouiTicketId

Identifiant unique d'un ticket de requête de correspondance à annuler.

Type. String (chaîne)

Version315

Amazon GameLift Manuel du développeurRéférence d’API de serveur pour Unreal Engine

 : obligatoire.  : oui

GameLift Référence d’API de serveur pour UnrealEngineCette référence API GameLift Server peut vous aider à préparer les projets de jeux Unreal Engine quevous utiliserez avec GameLift. Pour plus d'informations sur le processus d'intégration, consultez AjouterGameLift vers votre serveur de jeux (p. 46).

Cette API est définie dans GameLiftServerSDK.h et GameLiftServerSDKModels.h.

Pour configurer le plug-in Unreal Engine et consulter des exemples de code Ajout d'Amazon GameLift à unprojet de serveur de jeux Unreal Engine (p. 40).

• Actions: (p. 316)• Types de données (p. 321)

GameLift Référence d’API de serveur pour Unreal Engine :Actions:Cette référence API GameLift Server peut vous aider à préparer les projets de jeux Unreal Engine quevous utiliserez avec GameLift. Pour plus d'informations sur le processus d'intégration, consultez AjouterGameLift vers votre serveur de jeux (p. 46).

Cette API est définie dans GameLiftServerSDK.h et GameLiftServerSDKModels.h.

Pour configurer le plug-in Unreal Engine et consulter des exemples de code Ajout d'Amazon GameLift à unprojet de serveur de jeux Unreal Engine (p. 40).

• Actions:• Types de données (p. 321)

AcceptPlayerSession()

Informe le service GameLift qu'un joueur avec l'ID de session de joueur spécifié s'est connecté auprocessus serveur et attend une validation. GameLift vérifie que l'ID de session de joueur est valide, c'est-à-dire que l'ID de joueur a réservé un emplacement de joueur dans la session de jeu. Une fois la validationeffectuée, GameLift fait passer l'emplacement de joueur de l'état RESERVED à ACTIVE.

Syntax

FGameLiftGenericOutcome AcceptPlayerSession(const FString& playerSessionId)

Parameters

playerSessionId

ID unique émis par le service Amazon GameLift en réponse à un appel d'API du kit AWS SDKAmazon GameLiftCreatePlayerSession. Le client de jeu fait référence à cet ID lors de la connexion auprocessus serveur.

Type : FString

Version316

Amazon GameLift Manuel du développeurRéférence d’API de serveur pour Unreal Engine

Requis : non

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

ActivateGameSession()Informe le service GameLift que le processus serveur a activé une session de jeu et est maintenant prêtà recevoir des connexions de joueur. Cette action doit être appelée dans le cadre de la fonction de rappelonStartGameSession(), une fois que l'initialisation de toutes les sessions de jeu est terminée.

Syntax

FGameLiftGenericOutcome ActivateGameSession()

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

GetGameSessionId()Extrait l'ID de la session de jeu actuellement hébergée par le processus serveur, si ce dernier est actif.

Syntax

FGameLiftStringOutcome GetGameSessionId()

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

En cas de réussite, renvoie l'ID de session de jeu en tant qu'objet FGameLiftStringOutcome. En casd'échec, renvoie un message d'erreur.

GetSdkVersion()Renvoie le numéro de version actuel du kit SDK intégré dans le processus serveur.

Syntax

FGameLiftStringOutcome GetSdkVersion();

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

En cas de réussite, renvoie la version actuelle du kit SDK en tant qu'objet FGameLiftStringOutcome.La chaîne renvoyée inclut uniquement le numéro de version (par ex. « 3,15 pouces »). En cas d'échec,renvoie un message d'erreur.

Version317

Amazon GameLift Manuel du développeurRéférence d’API de serveur pour Unreal Engine

Example

Aws::GameLift::AwsStringOutcome SdkVersionOutcome = Aws::GameLift::Server::GetSdkVersion();

InitSDK()Initialise le kit SDK GameLift. Cette méthode doit être appelée au lancement, avant l'exécution de touteautre initialisation liée à GameLift.

Syntax

FGameLiftGenericOutcome InitSDK()

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

ProcessEnding()Informe le service GameLift que le processus serveur est en cours d'arrêt. Cette méthode doit être appeléeaprès toutes les autres tâches de nettoyage, y compris l'arrêt de toutes les sessions de jeu actives.Cette méthode doit quitter avec un code de sortie 0 ; un code de sortie différent de 0 génère un messaged'événement indiquant que le processus ne s'est pas fermé correctement.

Syntax

FGameLiftGenericOutcome ProcessEnding()

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

ProcessReady()Informe le service GameLift que le processus serveur est prêt à héberger des sessions de jeu. Appelezcette méthode après avoir réussi à appeler InitSDK() (p. 318) et la réalisation des tâches de configurationrequises avant que le processus serveur puisse héberger une session de jeu. Cette méthode ne doit êtreappelée qu’une seule fois par processus.

Syntax

FGameLiftGenericOutcome ProcessReady(FProcessParameters &processParameters)

Parameters

FProcessParameters

Objet FProcessParameters (p. 322) communiquant les informations suivantes relatives au processusserveur :

Version318

Amazon GameLift Manuel du développeurRéférence d’API de serveur pour Unreal Engine

• Noms des méthodes de rappel, mises en œuvre dans le code du serveur de jeux, que le serviceGameLift appelle pour communiquer avec le processus serveur.

• Numéro de port sur lequel le processus serveur écoute.• Chemin vers les fichiers spécifiques à une session de jeu que vous voulez qu'GameLift capture et

stocke.

 : obligatoire.  : oui

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

Example

Consultez l'exemple de code dans Utilisation du plug-in Unreal Engine (p. 41).

RemovePlayerSession()

Informe le service GameLift qu'un joueur avec l'ID de session de joueur spécifié s'est déconnecté duprocessus serveur. En réponse, GameLift fait passer l'emplacement de joueur à l'état disponible, ce qui luipermet d'être attribué à un nouveau joueur.

Syntax

FGameLiftGenericOutcome RemovePlayerSession(const FString& playerSessionId)

Parameters

playerSessionId

ID unique émis par le service Amazon GameLift en réponse à un appel d'API du kit AWS SDKAmazon GameLiftCreatePlayerSession. Le client de jeu fait référence à cet ID lors de la connexion auprocessus serveur.

Type : FString

Requis : non

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

StartMatchBackfill

Envoie une demande de recherche de nouveaux joueurs pour des emplacements ouverts dans unesession de jeu créée avec FlexMatch. Voir aussi l'action AWS SDK StartMatchBackfill(). Avec cette action,les requêtes de renvoi de correspondance peuvent être initiées par processus de serveur de jeu quihéberge la session de jeu. Découvrez la fonction de renvoi FlexMatch dans Renvoi de jeux existantsavecFlexMatch (p. 85).

Cette action est asynchrone. Si de nouveaux joueurs sont mis en relation, le service GameLift fournit lesdonnées du matchmaker mises à jour à l'aide de la fonction de renvoi OnUpdateGameSession().

Un processus de serveur ne peut comporter qu'une seule requête de renvoi de correspondance à la fois.Pour envoyer une nouvelle requête, appelez d'abord StopMatchBackfill() (p. 320) pour annuler la requêted'origine.

Version319

Amazon GameLift Manuel du développeurRéférence d’API de serveur pour Unreal Engine

Syntax

FGameLiftStringOutcome StartMatchBackfill (FStartMatchBackfillRequest &startBackfillRequest);

Parameters

FStartMatchBackfillRequest

Objet FStartMatchBackfillRequest (p. 323) qui communique les informations suivantes :• ID de ticket à attribuer à la requête de renvoi. Cette information est facultative ; si aucun ID n'est

fourni, GameLift en génère automatiquement un.• Matchmaker auquel envoyer la requête. L'ARN de configuration complet est obligatoire. Cette valeur

peut être acquise à partir des données matchmaker de la session de jeu.• ID de la session de jeu en cours de renvoi.• Données de correspondance disponibles pour les joueurs actuels de la session de jeu.

 : obligatoire.  : oui

Valeur renvoyée

En cas de réussite, renvoie le ticket de renvoi de correspondance sous la forme d'un objetFGameLiftStringOutcome. En cas d'échec, renvoie un message d'erreur. Le statut du ticket peut êtresuivi à l'aide de l'action AWS SDK DescribeMatchmaking().

StopMatchBackfill()

Annule une requête de renvoi de correspondance active qui a été créée avec StartMatchBackfill (p. 319).Voir aussi l'action AWS SDK StopMatchmaking(). Découvrez la fonction de renvoi FlexMatch dans Renvoide jeux existants avecFlexMatch (p. 85).

Syntax

FGameLiftGenericOutcome StopMatchBackfill (FStopMatchBackfillRequest &stopBackfillRequest);

Parameters

StopMatchBackfillRequest

Objet FStopMatchBackfillRequest (p. 324) qui identifie le ticket de correspondance à annuler :• Identifiant de ticket attribué à la requête de renvoi en cours d'annulation• matchmaker auquel a été envoyée la requête• session de jeu associée à la requête de renvoi

 : obligatoire.  : oui

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

TerminateGameSession()

Cette méthode est obsolète avec version 4.0.1. Au lieu de cela, le processus serveur doit appelerProcessEnding() (p. 318) après la fin d’une session de jeu.

Version320

Amazon GameLift Manuel du développeurRéférence d’API de serveur pour Unreal Engine

Avertit le GameLift que le processus serveur a terminé la session de jeu actuelle. Cette action est appeléelorsque le processus serveur reste actif et prêt à héberger une nouvelle session de jeu. Elle ne doit êtreappelée qu’une fois la procédure de fin de session de jeu terminée, car elle signale à GameLift que leprocessus serveur est immédiatement disponible pour héberger une nouvelle session de jeu.

Cette action n’est pas appelée si le processus serveur est arrêté après l’arrêt de la session de jeu. Au lieude cela, appelez ProcessEnding() (p. 318) pour indiquer que la session de jeu et le processus serveur seterminent tous les deux.

Syntax

FGameLiftGenericOutcome TerminateGameSession()

Parameters

Cette action n'a aucun paramètre.

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

UpdatePlayerSessionCreationPolicy()

Met à jour la capacité de la session de jeu à accepter de nouvelles sessions de joueur. Une session de jeupeut être définie pour accepter ou refuser toutes les nouvelles sessions joueur. (Consultez aussi l'actionUpdateGameSession() dans le manuel Référence API GameLift Server).

Syntax

FGameLiftGenericOutcome UpdatePlayerSessionCreationPolicy(EPlayerSessionCreationPolicy policy)

Parameters

Policy

Valeur indiquant si la session de jeu accepte ou non de nouveaux joueurs.

Type. EPlayerSessionCreationPolicy énumération. Les valeurs valides sont les suivantes :• ACCEPT_ALL – Accepter toutes les nouvelles sessions de joueur.• DENY_ALL – Refuser toutes les nouvelles sessions de joueur.

 : obligatoire.  : oui

Valeur renvoyée

Renvoie un résultat générique indiquant une réussite ou un échec avec un message d'erreur.

GameLift Référence d’API de serveur pour Unreal Engine : Typesde donnéesCette référence API GameLift Server peut vous aider à préparer les projets de jeux Unreal Engine quevous utiliserez avec GameLift. Pour plus d'informations sur le processus d'intégration, consultez AjouterGameLift vers votre serveur de jeux (p. 46).

Version321

Amazon GameLift Manuel du développeurRéférence d’API de serveur pour Unreal Engine

Cette API est définie dans GameLiftServerSDK.h et GameLiftServerSDKModels.h.

Pour configurer le plug-in Unreal Engine et consulter des exemples de code Ajout d'Amazon GameLift à unprojet de serveur de jeux Unreal Engine (p. 40).

• Actions: (p. 316)• Types de données

FProcessParameters

Ce type de données contient l'ensemble des paramètres envoyés au service GameLift dans un appelProcessReady() (p. 318).

Contents

port

Numéro de port sur lequel le processus serveur écoute les nouvelles connexions de joueur. La valeurdoit être comprise dans la plage de ports configurée pour toutes les flottes déployant cette version degénération du serveur de jeux. Ce numéro de port est inclus dans les objets de session de jeu et desession de joueur, que les sessions de jeu utilisent pour se connecter à un processus serveur.

Type. Integer

 : obligatoire.  : ouilogParameters

Objet comportant une liste de chemins de répertoires vers les fichiers journaux de sessions de jeu.

Type. TArray<ChaîneF>

 : obligatoire. Non.onStartGameSession

Nom de la fonction de rappel que le GameLift Le service appelle pour activer une nouvelle session dejeu. GameLift appelle cette fonction en réponse à la demande du client CréerSessionJeu. La fonctionde rappel prend un objet GameSession (défini dans le manuel Référence API GameLift Server).

Type. SéanceJeuDébutJeuF

 : obligatoire.  : ouionProcessTerminate

Nom de la fonction de rappel que le GameLift Le service appelle pour forcer le processus serveur àarrêter. Après l'appel de cette fonction, GameLift patiente cinq minutes afin que le processus serveurs'arrête et réponde avec un appel ProcessEnding() (p. 318) avant d'arrêter le processus serveur.

Type. DéléguerSimpleF

 : obligatoire. Non.onHealthCheck

Nom de la fonction de rappel que le GameLift pour demander un rapport d’état de santé au processusserveur. GameLift appelle cette fonction toutes les 60 secondes. Après l'appel de cette fonction,GameLift attend une réponse pendant 60 secondes, et si aucune réponse n'est reçue, enregistre leprocessus serveur comme n'étant pas sain.

Version322

Amazon GameLift Manuel du développeurRéférence d’API de serveur pour Unreal Engine

Type. Bilan de santé FOn

 : obligatoire. Non.onUpdateGameSession

Nom de la fonction de rappel que le GameLift Le service appelle pour transmettre un objet desession de jeu mis à jour au processus serveur. GameLift appelle cette fonction lorsqu’un remblaicorrespondant (p. 85) a été traitée afin de fournir des données mises à jour sur le matchmaker. Iltransmet un objet GameSession, une mise à jour d'état (updateReason), ainsi que l'identifiant deticket de renvoi de mise en relation.

Type. SéanceJeuMiseAJourJust

 : obligatoire. Non.

FStartMatchBackfillRequest

Ce type de données est utilisé pour envoyer une requête de renvoi de correspondance. Les informationssont communiquées au service GameLift dans un appel StartMatchBackfill (p. 319).

Contents

GameSessionArn

Identifiant de session de jeu unique. L'action d'API GetGameSessionId() (p. 317) renvoie l'identifiantau format ARN.

Type. Chaîne de fenêtrage

 : obligatoire.  : ouiMatchmakingConfigurationArn

Identifiant unique, sous la forme d'un ARN, pour le matchmaker à utiliser pour cette requête. Pourtrouver le matchmaker qui a été utilisé pour créer la session de jeu d'origine, recherchez dans l'objetde session de jeu, dans la propriété de données de matchmaker. Découvrez les données matchmakerdans Utiliser des données de matchmaker (p. 84).

Type. Chaîne de fenêtrage

 : obligatoire.  : ouiJoueurs

Ensemble de données représentant tous les joueurs qui sont actuellement dans la session de jeu. Lematchmaker utilise ces informations pour rechercher de nouveaux joueurs qui constituent de bonnescorrespondances pour les joueurs actuels. Pour une description du format d'objet Joueur, consultez lemanuel Amazon GameLift API Reference Guide. Pour trouver des attributs de joueur, des identifiantset des affectations d'équipe, recherchez dans l'objet de session de jeu, dans la propriété des donnéesde matchmaker. Si une latence est utilisée par le matchmaker, collectez la latence mise à jour pour larégion actuelle et incluez-la dans les données de chaque joueur.

Type. Barre d’outils<CoucheFP>

 : obligatoire.  : ouiTicketId

Identifiant unique pour une correspondance ou un ticket de requête de renvoi de correspondance. Siaucune valeur n'est fournie ici, Amazon GameLift en génère une sous la forme d'un UUID. Utilisez cetidentifiant pour suivre l'état du ticket de renvoi de correspondance ou annuler la requête si nécessaire.

Version323

Amazon GameLift Manuel du développeurRéférence FlexMatch

Type. Chaîne de fenêtrage

 : obligatoire. Non.

FStopMatchBackfillRequest

Ce type de données est utilisé pour annuler une demande de renvoi de correspondance. Les informationssont communiquées au service GameLift dans un appel StopMatchBackfill() (p. 320).

Contents

GameSessionArn

Identifiant de session de jeu unique associé à la requête en cours d'annulation.

Type. Chaîne de fenêtrage

 : obligatoire.  : ouiMatchmakingConfigurationArn

Identifiant unique du matchmaker auquel cette requête a été envoyée.

Type. Chaîne de fenêtrage

 : obligatoire.  : ouiTicketId

Identifiant unique d'un ticket de requête de correspondance à annuler.

Type. Chaîne de fenêtrage

 : obligatoire.  : oui

Référence GameLift FlexMatchCette section contient la documentation de référence pour la mise en relation avec GameLift FlexMatch.

Rubriques• ensemble FlexMatch de règles schéma (p. 324)• Langage FlexMatch des règles (p. 331)• Événements FlexMatch de mise en relation (p. 337)

ensemble FlexMatch de règles schémaLes ensembles de règles FlexMatch utilisent le schéma d’ensemble de règles standard pour les parties depetite envergure et à grande échelle. Utilisez ce schéma avec le langage de règles décrit dans LangageFlexMatch des règles (p. 331) lors de la création des règles de mise en relation de votre jeu.

En savoir plus sur la création de règles FlexMatch :

• Concevoir un ensemble FlexMatch de règles (p. 158)• Créer des ensembles de règles de mise en relation (p. 167)

Version324

Amazon GameLift Manuel du développeurSchéma d'ensemble de règles

• Exemples FlexMatch d'ensembles de règles (p. 169)• Langage FlexMatch des règles (p. 331)

Schéma d’ensemble de règles pour les parties de petiteenvergureLe schéma suivant documente toutes les propriétés possibles et les valeurs autorisées pour un ensemblede règles utilisé pour créer des rencontres impliquant jusqu'à 40 joueurs.

{ "name": "string", "ruleLanguageVersion": "1.0", "playerAttributes":[{ "name": "string, "type": <"string", "number", "string_list", "string_number_map">, "default": "string" }], "algorithm": { "strategy": "exhaustiveSearch", "batchingPreference": <"random", "sorted">, "sortByAttributes": [ "string" ], "expansionAgeSelection": <"newest", "oldest">, "backfillPriority": <"normal", "low", "high"> }, "teams": [{ "name": "string", "maxPlayers": number, "minPlayers": number, "quantity": integer }], "rules": [{ "type": "distance", "name": "string", "description": "string", "measurements": "string", "referenceValue": number, "maxDistance": number, "minDistance": number, "partyAggregation": <"avg", "min", "max"> },{ "type": "comparison", "name": "string", "description": "string", "measurements": "string", "referenceValue": number, "operation": <"<", "<=", "=", "!=", ">", ">=">, "partyAggregation": <"avg", "min", "max"> },{ "type": "collection", "name": "string", "description": "string", "measurements": "string", "referenceValue": number, "operation": <"intersection", "contains", "reference_intersection_count">, "maxCount": number, "minCount": number, "partyAggregation": <"union", "intersection"> },{ "type": "latency", "name": "string", "description": "string", "maxLatency": number,

Version325

Amazon GameLift Manuel du développeurSchéma d'ensemble de règles

"maxDistance": number, "distanceReference": number, "partyAggregation": <"avg", "min", "max"> },{ "type": "distanceSort", "name": "string", "description": "string", "sortDirection": <"ascending", "descending">, "sortAttribute": "string", "mapKey": <"minValue", "maxValue">, "partyAggregation": <"avg", "min", "max"> },{ "type": "absoluteSort", "name": "string", "description": "string", "sortDirection": <"ascending", "descending">, "sortAttribute": "string", "mapKey": <"minValue", "maxValue">, "partyAggregation": <"avg", "min", "max"> }], "expansions": [{ "target": "string", "steps": [{ "waitTimeSeconds": number, "value": number }, { "waitTimeSeconds": number, "value": number }] }]}

Schéma d’ensemble de règles pour les parties à grande échelleLe schéma suivant documente toutes les propriétés possibles et les valeurs autorisées pour un ensemblede règles utilisé pour créer des parties impliquant plus de 40 joueurs. Si le nombre total de maxPlayersvaleurs pour toutes les équipes de l'ensemble de règles dépasse 40, FlexMatch traite les demandes demise en relation qui utilisent cet ensemble de règles selon les directives relatives aux parties à grandeéchelle.

{ "name": "string", "ruleLanguageVersion": "1.0", "playerAttributes":[{ "name": "string, "type": <"string", "number", "string_list", "string_number_map">, "default": "string" }], "algorithm": { "strategy": "balanced", "batchingPreference": <"largestPopulation", "fastestRegion">, "balancedAttribute": "string", "expansionAgeSelection": <"newest", "oldest">, "backfillPriority": <"normal", "low", "high"> }, "teams": [{ "name": "string", "maxPlayers": number, "minPlayers": number, "quantity": integer }], "rules": [{ "type": "latency",

Version326

Amazon GameLift Manuel du développeurSchéma d'ensemble de règles

"name": "string", "description": "string", "maxLatency": number, "partyAggregation": <"avg", "min", "max"> }], "expansions": [{ "target": "string", "steps": [{ "waitTimeSeconds": number, "value": number }, { "waitTimeSeconds": number, "value": number }] }]}

Définitions des propriétés de schéma d'ensemble de règlesCette section définit chaque propriété du schéma de l'ensemble de règles. Pour plus d'informations sur lacréation d'un ensemble de règles, consultez Concevoir un ensemble FlexMatch de règles (p. 158) .

name

Étiquette descriptive pour l'ensemble de règles. Cette valeur n'est pas associée au nom attribué àla GameLift MatchmakingRuleSet ressource. Cette valeur est incluse dans les données de miseen relation décrivant une mise en relation terminée, mais elle n'est pas utilisée par les GameLiftprocessus.

Valeurs autorisées : String (chaîne)

Obligatoire? NonruleLanguageVersion

Version du langage d'expression de FlexMatch propriété en cours d'utilisation.

Valeurs autorisées : « 1.0 »

Obligatoire? OuiplayerAttributes

Ensemble de données de joueur incluses dans les demandes de mise en relation et utilisées dans leprocessus de mise en relation. Vous pouvez également déclarer des attributs ici pour que les donnéesde joueur soient incluses dans les données de mise en relation qui sont transmises aux serveurs dejeux, même si les données ne sont pas utilisées dans le processus de mise en relation.

Obligatoire? Nonname

Nom unique de l'attribut de joueur à utiliser par le matchmaker. Ce nom doit correspondre au nomde l'attribut de joueur qui est référencé dans les demandes de mise en relation.

Valeurs autorisées : String (chaîne)

Obligatoire? Ouitype

Type de données de la valeur d'attribut du joueur.

Valeurs autorisées : "string", "number", "string_list", "string_number_map"

Version327

Amazon GameLift Manuel du développeurSchéma d'ensemble de règles

Obligatoire? Ouidefault

Valeur par défaut à utiliser lorsqu'une demande de mise en relation n'en fournit pas pour unjoueur.

Valeurs autorisées : N'importe quelle valeur autorisée pour l'attribut de joueur.

Obligatoire? Nonalgorithm

Des paramètres de configuration facultatifs pour personnaliser le processus de mise en relation.

Obligatoire? Nonstrategy

Méthode à utiliser lors de la génération de correspondances. Si cette propriété n'est pas définie, lecomportement par défaut est «haustiveSearch ».

Valeurs autorisées :• Méthode de correspondance – standard « exhaustiveSearch ». FlexMatch forme une

correspondance autour du ticket le plus ancien dans un lot en évaluant les autres tickets dansle groupe en fonction d'un ensemble de règles de correspondance personnalisées. Cettestratégie est utilisée pour les parties impliquant 40 joueurs ou moins. Lors de l'utilisation de cettestratégie, batchingPreference doit être défini sur « random » ou « sorted ».

• Méthode « équilibrée » optimisée pour former rapidement des parties à beaucoup de joueurs.–Cette stratégie est utilisée uniquement pour les parties impliquant de 41 à 200 joueurs.Elle forme les rencontres en triant au préalable le pool de ticket, en créant des rencontrespotentielles et en affectant des joueurs à des équipes, puis en équilibrant chaque équipe dansune rencontre à l'aide d'un attribut de joueur spécifié. Par exemple, cette stratégie peut êtreutilisée pour équilibrer les niveaux de compétence moyens de toutes les équipes d'une miseen relation. Lors de l'utilisation de cette stratégie, balancedAttribute doit être défini etbatchingPreference doit être défini sur « largestPopulation » ou « fastestRegion ». Laplupart des types de règles personnalisées ne sont pas reconnus avec cette stratégie.

Obligatoire? OuibatchingPreference

Méthode de tri préalable à utiliser avant le regroupement des tickets pour la génération derencontres. Le tri préalable du pool de tickets entraîne le regroupement des tickets en fonctiond'une caractéristique spécifique, qui a tendance à augmenter l'unicité entre les joueurs dans lesdernières rencontres.

Valeurs autorisées :• "random" – Valide uniquement avec strategy = "exhaustiveSearch". Aucun tri préalable n'est

effectué ; les tickets du groupe sont traités par lot de façon aléatoire. Il s'agit du comportementpar défaut d'une stratégie de recherche exhaustive.

• "sorted" – Valide uniquement avec strategy = "exhaustiveSearch". Le groupe de ticket estpré-trié en fonction des attributs de joueur répertoriés dans sortbyAttributes .

• "largestPopulation" – Valide uniquement avec strategy = "balanced". Le groupe de ticketest pré-trié par régions où les joueurs signalent les niveaux de latence acceptables. Il s'agit ducomportement par défaut d'une stratégie équilibrée.

• "fastestRegion" – Valide uniquement avec strategy = "balanced". Le groupe de ticket est pré-trié par régions où les joueurs signalent leurs niveaux de latence les plus faibles. Les partiessuivantes prennent plus de temps, mais la latence pour tous les joueurs a tendance à êtrefaible.

Version328

Amazon GameLift Manuel du développeurSchéma d'ensemble de règles

Obligatoire? OuibalancedAttribute

Nom d'un attribut de joueur à utiliser lors de la création de parties à grande échelle avec lastratégie équilibrée.

Valeurs autorisées : Tout attribut déclaré dans playerAttributes avec type = "number".

Obligatoire? Oui, si strategy = "balanced".sortByAttributes

Liste des attributs de joueur à utiliser lors du tri préalable du pool de ticket avant le traitement parlots. Cette propriété est uniquement utilisée lors du tri préalable avec la stratégie de rechercheexhaustive. L'ordre de la liste d'attributs détermine l'ordre de tri. FlexMatch utilise la convention detri standard pour les valeurs alpha et numériques.

Valeurs autorisées : Tout attribut déclaré dans playerAttributes .

Obligatoire? Oui, si batchingPreference = "sorted".backfillPriority

Méthode de hiérarchisation pour la correspondance des tickets de remplissage. Cette propriétédétermine quand FlexMatch traite les tickets de remplissage dans un lot. Elle est uniquementutilisée lors du tri préalable avec la stratégie de recherche exhaustive. Si cette propriété n'est pasdéfinie, le comportement par défaut est « normal ».

Valeurs autorisées :• « normal » – Le type de demande d'un ticket (remplissage ou nouvelle correspondance) n'est

pas pris en compte lors de la formation de correspondances.• « high » – : un lot de tickets est trié par type de demande (puis par âge) et FlexMatch tente de

faire correspondre les tickets de remplissage en premier.• niveau faible : un lot de tickets est trié par type de demande (puis par âge) et – tente d'abord de

mettre en correspondance les tickets autres que les tickets de remplissage.FlexMatch

Obligatoire? NonexpansionAgeSelection

Méthode de calcul du temps d'attente pour une extension de règle de correspondance. Lesextensions sont utilisées pour assouplir les exigences de mise en relation si aucune partie n'a étéeffectuée après un certain délai. Le temps d'attente est calculé en fonction de l'âge des ticketsqui se trouvent déjà dans la partie partiellement remplie. Si cette propriété n'est pas définie, lecomportement par défaut est « le plus récent ».

Valeurs autorisées :• Le temps – d'attente de l'extension « latest » est calculé en fonction du ticket avec l'horodatage

de création le plus récent dans la correspondance partiellement terminée. Les extensions onttendance à se déclencher plus lentement, car un ticket plus récent peut redémarrer l'horloge dutemps d'attente.

• Le temps – d'attente d'extension « plus ancien » est calculé en fonction du ticket avecl'horodatage de création le plus ancien dans la mise en relation. Les extensions ont tendance àêtre déclenchées plus rapidement.

Obligatoire? Nonteams

Configuration des équipes dans une mise en relation. Fournissez un nom d'équipe et une plage detaille pour chaque équipe. Un ensemble de règles doit définir au moins une équipe.

Version329

Amazon GameLift Manuel du développeurSchéma d'ensemble de règles

name

Nom unique de l'équipe. Les noms d'équipe peuvent être référencés dans les règles et lesextensions. Lors d'une mise en relation réussie, les joueurs sont attribués par nom d'équipe dansles données de mise en relation.

Valeurs autorisées : String (chaîne)

Obligatoire? OuimaxPlayers

Nombre maximal de joueurs pouvant être affectés à l'équipe.

Valeurs autorisées : Number

Obligatoire? OuiminPlayers

Nombre minimal de joueurs qui doivent être affectés à l'équipe pour que la mise en relation soitviable.

Valeurs autorisées : Number

Obligatoire? Ouiquantity

Nombre d'équipes de ce type à créer dans une mise en relation. Les équipes avec des quantitéssupérieures à 1 sont désignées par un nombre ajouté (« Red_1 », « Red_2 », etc.). Si cettepropriété n'est pas définie, la valeur par défaut est « 1 ».

Valeurs autorisées : Number

Obligatoire? Nonrules

Ensemble d'instructions de règle qui définissent comment évaluer les joueurs pour une mise enrelation.

Obligatoire? Nonname

Nom unique de la règle. Toutes les règles d'un ensemble de règles doivent avoir des nomsuniques. Les noms des règles sont référencés dans les journaux d'événements et les métriquesqui suivent l'activité associée à la règle.

Valeurs autorisées : String (chaîne)

Obligatoire? Ouidescription

Description textuelle de la règle. Ces informations ne sont pas utilisées dans le processus de miseen relation.

Valeurs autorisées : String (chaîne)

Obligatoire? Nontype

Type d'instruction de règle. Chaque type de règle a des propriétés supplémentaires qui doiventêtre définies. Pour plus d'informations sur la définition complète de chaque type de règle,consultez Langage FlexMatch des règles (p. 331) .

Version330

Amazon GameLift Manuel du développeurLangage des règles

Valeurs autorisées :• "distance" – Mesure la distance entre les valeurs numériques.• "comparaison" – Compare deux valeurs.• "collection" – Évalue les valeurs d'une collection, telles qu'un attribut de joueur qui est une

collection ou un ensemble de valeurs pour plusieurs joueurs.• "latence" – Évalue les données de latence régionale rapportées pour une demande de mise en

relation.• Méthode de tri – explicite « distanceSort » qui trie les tickets dans un lot en fonction de la façon

dont un attribut de joueur spécifié avec une valeur numérique est comparé au ticket le plusancien du lot.

• Méthode de tri – explicite « absoluteSort » qui trie les tickets dans un lot selon qu'un attribut dejoueur spécifié est ou non comparé au ticket le plus ancien du lot.

Obligatoire? Ouiexpansions

Règles pour assouplir les exigences de mise en relation au fil du temps lorsqu'une mise en relation nepeut pas être effectuée. Configurez les extensions sous la forme d'une série d'étapes qui s'appliquentprogressivement afin de faciliter la recherche des correspondances. Par défaut, FlexMatch calculele temps d'attente en fonction de l'âge du dernier ticket ajouté à une mise en relation. Vous pouvezmodifier la façon dont les temps d'attente d'extension sont calculés à l'aide de la propriété d'algorithmeexpansionAgeSelection .

Les temps d'attente d'extension sont des valeurs absolues, de sorte que chaque étape doit avoir untemps d'attente plus long que l'étape précédente. Par exemple, pour planifier une série progressived'extensions, vous pouvez utiliser des temps d'attente de 30 secondes, 40 secondes et 50 secondes.Les temps d'attente ne peuvent pas dépasser la durée maximale autorisée pour une demande de miseen relation, qui est définie dans la configuration de mise en relation.

Obligatoire? Nontarget

Elément d'ensemble de règles à assouplir. Vous pouvez assouplir les propriétés de tailled'équipe ou toute autre propriété d'instruction de règle. La syntaxe est « <componentname>règle/nom de l'équipe> ».<property name> Par exemple, pour modifier les taillesminimales de l'équipe : teams[Red, Yellow].minPlayers. Pour modifier l'exigence decompétence minimale dans une instruction de règle de comparaison nommée « minSkill » :rules[minSkill].referenceValue.

Obligatoire? Ouisteps

waitTimeSeconds

Durée d'attente, en secondes, avant d'appliquer la nouvelle valeur à l'élément de l'ensemblede règles cible.

Obligatoire? Ouivalue

Nouvelle valeur pour l'élément de l'ensemble de règles cible.

Langage FlexMatch des règlesUtilisez la syntaxe suivante pour les expressions de propriété lors de l'écriture des règles pour lesensembles de règles FlexMatch.

Version331

Amazon GameLift Manuel du développeurLangage des règles

En savoir plus sur la création de règles FlexMatch :

• Créer un ensemble FlexMatch de règles (p. 158)• Créer des ensembles de règles de mise en relation (p. 167)• Exemples FlexMatch d'ensembles de règles (p. 169)

Types de règleFlexMatch prend en charge les types de règles suivants : Chaque type de règle nécessite un ensemble depropriétés, qui sont décrites ici.

Règle de distance (distance)

Les règles de distance permettent de mesurer la différence entre deux valeurs numériques, telles quela distance entre deux niveaux de compétence. Par exemple, une règle de distance peut exiger quetous les joueurs soient à deux niveaux de compétence les uns des autres.

Propriétés des règles de distance• measurements – Valeur d'attribut de joueur permettant de mesurer la distance ; doit être une valeur

numérique.• referenceValue – Valeur numérique permettant de mesurer la distance par rapport à une mise en

relation potentielle.• minDistance/maxDistance – Distance minimale ou maximale autorisée pour une mise en relation

réussie.• partyAggregation–Méthode de gestion des tickets avec plusieurs joueurs (parties). Les options

valides sont les valeurs minimales (min), maximales (max) ou moyennes (avg) pour les joueurs d'unticket. La valeur par défaut est avg.

Règle de comparaison (comparison)

Les règles de comparaison mesurent une valeur d'attribut de joueur par rapport à une autre valeur.Il existe deux types de règles de comparaison. Le premier type compare une valeur d'attribut à unevaleur de référence fournie. Spécifiez la valeur de référence et une opération de comparaison valide.Par exemple, la règle peut exiger que les joueurs mis en relation aient un niveau de compétence de24 ou plus. Le deuxième type compare les valeurs d'attribut de joueur entre les joueurs d'une équipeou d'une mise en relation pour déterminer si tous les joueurs ou aucun joueur ont la même valeurd'attribut. Avec ce type de règle de comparaison, omettez la valeur de référence et spécifiez l'opérationégale (« = ») ou non égale (« ! = »). Par exemple, la règle peut exiger que tous les joueurs de la miseen relation choisissent la même relation de jeu ou qu'aucun joueur d'une équipe ne choisisse le mêmepersonnage.

Propriétés des règles de comparaison• measurements – Valeur d'attribut du joueur à comparer.• referenceValue – Valeur permettant d'évaluer la mesure par rapport à une mise en relation

potentielle.• operation – Mode d'évaluation de la mesure. Les opérations valides sont les suivantes : <, <=,=, !=, >, >=.

• partyAggregation–Méthode de gestion des tickets avec plusieurs joueurs (parties). Les optionsvalides sont les valeurs minimales (min), maximales (max) ou moyennes (avg) pour les joueurs d'unticket. La valeur par défaut est avg.

Règle de collection (collection)

Les règles de collection évaluent les collections de valeurs d'attribut du joueur. Une collection peutcontenir des valeurs d'attribut pour plusieurs joueurs, un attribut de joueur qui est une collection (une

Version332

Amazon GameLift Manuel du développeurLangage des règles

liste de chaînes), ou les deux. Par exemple, une règle de collection peut examiner les personnageschoisis par les joueurs d'une équipe et exiger que l'équipe possède au moins un personnagespécifique.

Propriétés des règles de collecte• measurements – Collection de valeurs d'attributs de joueur à évaluer. Les valeurs d'attribut doivent

être des listes de chaînes.• referenceValue–Valeur (ou collection de valeurs) permettant d'évaluer les mesures par rapport à

une mise en relation potentielle.• operation – Mode d'évaluation d'une collection de mesures. Les opérations valides sont les

suivantes :• intersection mesure le nombre de valeurs communes à toutes les collections des joueurs.

Voir la MapOverlap règle dans Exemple 4 : Utiliser le tri explicite pour trouver les meilleurescorrespondances (p. 175) .

• contains mesure le nombre de collections d'attributs de joueur contenant une valeur deréférence spécifique. Voir la OverallMedicLimit règle dans Exemple 3 : Définir les exigences auniveau de l'équipe et les limites de latence (p. 173) .

• reference_intersection_count mesure l'intersection entre une collection d'attributs dejoueur et une collection de valeurs de référence. Chaque collection d'attributs de joueur (listede chaînes) définie dans measurements est évaluée séparément par rapport à la collection deréférences. Cette opération peut être utilisée pour évaluer les différents attributs de joueur. Voirla OpponentMatch règle dans Exemple 5 : Recherche d'intersections sur plusieurs attributs dejoueur (p. 177) .

• minCount/maxCount – Nombre minimal ou maximal autorisé pour une mise en relation réussie.• partyAggregation–Méthode de gestion des tickets avec plusieurs joueurs (parties). Les options

valides sont l'utilisation du union ou intersection des valeurs pour les joueurs d'un ticket. Lavaleur par défaut est union.

Latency rule (latency)

Les règles de latence évaluent les rapports de latence des joueurs par région. Par exemple, une règlepeut exiger que les joueurs correspondants aient une latence dans la même région qui est inférieureà une limite maximale. Il s'agit du seul type de règle autorisé pour les parties à grande échelle et leparamètre maxLatency est la seule propriété autorisée.

Propriétés des règles de latence• maxLatency – Plus haute valeur de latence acceptable pour une région. Pour chaque ticket,

ignorez toutes les régions qui dépassent cette latence.• maxDistance–Différence maximale entre la latence de chaque ticket et la valeur de référence de

distance.• distanceReference–A utiliser avec maxDistance . Valeur numérique permettant de mesurer

la distance par rapport à une mise en relation réussie. Pour la latence, cette valeur est unregroupement de valeurs de latence de plusieurs joueurs. Les options valides sont la valeurminimale (min) ou moyenne (avg) de la latence du joueur. (Consultez la section Expressions depropriété.)

• partyAggregation–Méthode de gestion des tickets avec plusieurs joueurs (parties). Les optionsvalides sont les valeurs minimales (min), maximales (max) ou moyennes (avg) pour les joueurs d'unticket. La valeur par défaut est avg.

Règle de tri des distances (distanceSort)

Le tri de distance est une option de tri explicite qui demande au matchmaker de trier un lot de ticketsde mise en relation en fonction d'un attribut de joueur. Une règle de tri de distance évalue les tickets enfonction de la distance par rapport au ticket le plus ancien.

Propriétés des règles de tri de la distance

Version333

Amazon GameLift Manuel du développeurLangage des règles

• sortDirection–Direction de tri des tickets de mise en relation. Les options valides sontascending ou descending.

• sortAttribute – Attribut sur lequel trier les joueurs.• mapKey – Mode d'évaluation de l'attribut de joueur s'il s'agit d'une carte. Les options valides sont les

suivantes :• minValue: Pour le ticket le plus ancien, recherchez la clé avec la valeur la plus faible.• maxValue: Pour le ticket le plus ancien, recherchez la clé avec la valeur la plus élevée.

• partyAggregation–Méthode de gestion des tickets avec plusieurs joueurs (parties). Les optionsvalides sont les valeurs minimales (min), maximales (max) ou moyennes (avg) pour les joueurs d'unticket. La valeur par défaut est avg.

Règle de tri absolu (absoluteSort)

Le tri absolu est une option de tri explicite qui demande au matchmaker de trier un lot de tickets demise en relation en fonction d'un attribut de joueur. Un tri absolu évalue les tickets de mise en relationselon que son attribut de joueur correspond à celui du ticket le plus ancien.

Propriétés des règles de tri absolu• sortDirection–Direction de tri des tickets de mise en relation. Les options valides sontascending ou descending.

• sortAttribute – Attribut sur lequel trier les joueurs.• mapKey – Mode d'évaluation de l'attribut de joueur s'il s'agit d'une carte. Les options valides sont les

suivantes :• minValue: Pour le ticket le plus ancien, recherchez la clé avec la valeur la plus faible.• maxValue: Pour le ticket le plus ancien, recherchez la clé avec la valeur la plus élevée.

• partyAggregation–Méthode de gestion des tickets avec plusieurs joueurs (parties). Les optionsvalides sont les valeurs minimales (min), maximales (max) ou moyennes (avg) pour les joueurs d'unticket. La valeur par défaut est avg.

Expressions de propriétéLes expressions de propriété peuvent être utilisées pour définir certaines propriétés liées à la mise enrelation. Elles vous permettent d'utiliser des calculs et une logique lors de la définition d'une valeur depropriété. Les expressions de propriété se traduisent généralement par l'une des deux formes suivantes :

• Données de joueur individuelles.• Collections calculées de données de joueur individuelles.

Une expression de propriété valide identifie une valeur spécifique pour un seul joueur, une équipe ouune mise en relation. Les expressions partielle suivantes illustrent comment identifier les équipes et lesjoueurs :

Objectif Entrées Signification Output

Pour identifier uneéquipe spécifique dansune mise en relation :

teams[red] L'équipe Red Equipe

Pour identifier tous leséquipes d'une mise enrelation :

teams[*] Toutes les équipes List<Team>

Version334

Amazon GameLift Manuel du développeurLangage des règles

Objectif Entrées Signification Output

Pour identifier lesjoueurs d'une équipespécifique :

team[red].players Joueurs de l'équipe Red List<Player>

Pour identifier lesjoueurs d'une mise enrelation :

team[*].players Joueurs de la mise enrelation, regroupés paréquipe

List<List<Player>>

Le tableau suivant illustre certaines expressions de propriété valides qui s'appuient sur les exemplesprécédents :

Expression Signification Type obtenu

teams[red].players[playerid]Joueur IDs de tous les joueurs del'équipe Red

List<string>

teams[red].players.attributes[skill]Les attributs « skill » de tous lesjoueurs de l'équipe Red

List<number>

teams[*].players.attributes[skill]Les attributs « skill » de tous lesjoueurs de la mise en relation,regroupés par équipe

List<List<number>>

Les expressions de propriété peuvent être utilisées pour regrouper les données d'équipe à l'aide desfonctions ou combinaisons de fonctions suivantes :

Regroupement Entrées Signification Output

min List<number> Obtenir le minimum detous les chiffres de laliste.

number

max List<number> Obtenir le maximum detous les chiffres de laliste.

number

avg List<number> Obtenir la moyenne detous les chiffres de laliste.

number

median List<number> Obtenir la valeurmédiane de tous leschiffres de la liste.

number

sum List<number> Obtenir la somme detous les chiffres de laliste.

number

count List<?> Obtenir le nombred'éléments de la liste.

number

stddev List<number> Obtenir l'écart standardde tous les chiffres de laliste.

number

Version335

Amazon GameLift Manuel du développeurLangage des règles

Regroupement Entrées Signification Output

flatten List<List<?>> Transformer unecollection de listesimbriquées en une seuleliste contenant tous leséléments.

List<?>

set_intersection List<List<string>> Obtenez une listede chaînes qui sontdisponibles dans toutesles listes de chaînesd'une collection.

List<string>

Toutes les opérations ci-dessus

List<List<?>> Toutes les opérationssur une liste imbriquéefonctionnent surchaque sous-listeindividuellement pourproduire une liste derésultats.

List<?>

Le tableau suivant illustre certaines expressions de propriété valides qui utilisent les fonctionsd'agrégation :

Expression Signification Type obtenu

flatten(teams[*].players.attributes[skill]) Les attributs « skill » detous les joueurs de lamise en relation (nonregroupés)

List<number>

avg(teams[red].players.attributes[skill]) La compétencemoyenne de tous lesjoueurs de l'équipe Red

number

avg(teams[*].players.attributes[skill] La compétencemoyenne de chaqueéquipe de la mise enrelation

List<number>

avg(flatten(teams[*].players.attributes[skill])) Le niveau decompétence moyende tous les joueursde la mise en relation.Cette expression obtientune liste mise à platdes compétences desjoueurs, puis calculeleur moyenne.

number

count(teams[red].players) Nombre de joueurs del'équipe Red

number

count (teams[*].players) Nombre de joueurs dechaque équipe de lamise en relation

List<number>

Version336

Amazon GameLift Manuel du développeurÉvénements de mise en relation

Expression Signification Type obtenu

max(avg(teams[*].players.attributes[skill])) Plus haut niveau decompétence d'équipe dela mise en relation

number

Événements FlexMatch de mise en relationAmazon GameLift émet des événements qui sont liés au traitement de demandes de mise en relation.Toutes les événements qui sont répertoriés ici peuvent être publiés dans une rubrique Amazon SNS. Cesévénements sont également publiés sur Amazon CloudWatch Events. Pour plus d'informations sur lesévénements de mise en relation, consultez Configuration de la notification FlexMatch d'événement (p. 186).Pour plus d'informations sur les statuts des demandes de mise en relation, consultez MatchmakingTicket Référence d'API du Amazon GameLift service .

MatchmakingSearchingLa demande a été saisie dans la mise en relation. Cela inclut les nouvelles demandes et les demandes quifaisaient partie d'une mise en relation qui a échoué.

Ressource :ConfigurationArn

Détails : type, tickets,estimatedWaitMillisgameSessionInfo

Example

{ "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" } ] } }

Version337

Amazon GameLift Manuel du développeurÉvénements de mise en relation

}

PotentialMatchCreatedUne mise en relation potentielle a été créée. Le ticket est émis pour toutes les nouvelles mises en relationpotentielles, que l'acceptation soit obligatoire ou non.

Ressource : ConfigurationArn

Détails : type, tickets, acceptanceTimeout , acceptanceRequired , ,ruleEvaluationMetrics ,gameSessionInfomatchId

Example

{ "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" ], "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,

Version338

Amazon GameLift Manuel du développeurÉvénements de mise en relation

"failedCount": 0 }, { "ruleName": "NoobSegregation", "passedCount": 3, "failedCount": 0 } ], "acceptanceRequired": true, "type": "PotentialMatchCreated", "gameSessionInfo": { "players": [ { "playerId": "player-1", "team": "red" }, { "playerId": "player-2", "team": "blue" } ] }, "matchId": "3faf26ac-f06e-43e5-8d86-08feff26f692" }}

AcceptMatchLes joueurs ont accepté une mise en relation potentielle. Cet événement contient l'état d'acceptation actuelde chaque joueur de la mise en relation. Les données manquantes signifient qu' n'a pas été appelé pour cejoueur.AcceptMatch

Ressource : ConfigurationArn

Détails : type, tickets,matchIdgameSessionInfo

Example

{ "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",

Version339

Amazon GameLift Manuel du développeurÉvénements de mise en relation

"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" }}

AcceptMatchCompletedL'acceptation de la mise en relation est terminée, du fait de l'acceptation par un joueur, du rejet par unjoueur ou de l'expiration de l'acceptation.

Ressource : ConfigurationArn

Détails : type, tickets, acceptance,matchIdgameSessionInfo

Example

{ "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" } ] }, {

Version340

Amazon GameLift Manuel du développeurÉvénements de mise en relation

"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" }}

MatchmakingSucceededLa mise en relation a été réalisée avec succès et une session de jeu a été créée.

Ressource : ConfigurationArn

Détails : type, tickets,matchIdgameSessionInfo

Example

{ "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" } ] }, {

Version341

Amazon GameLift Manuel du développeurÉvénements de mise en relation

"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" }, { "playerId": "player-2", "playerSessionId": "psess-786b342f-9c94-44eb-bb9e-c1de46c472ce", "team": "blue" } ] }, "matchId": "c0ec1a54-7fec-4b55-8583-76d67adb7754" }}

MatchmakingTimedOutLa demande de mise en relation a échoué car elle a expiré.

Ressource : ConfigurationArn

Détails : type, tickets, ruleEvaluationMetrics , message,matchIdgameSessionInfo

Example

{ "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": [ {

Version342

Amazon GameLift Manuel du développeurÉvénements de mise en relation

"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" } ] } }}

MatchmakingCancelledLa demande de mise en relation a été annulée.

Ressource : ConfigurationArn

Détails : type, tickets, ruleEvaluationMetrics , message,matchIdgameSessionInfo

Example

{ "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": {

Version343

Amazon GameLift Manuel du développeurÉvénements de mise en relation

"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" } ] } }}

MatchmakingFailedLa demande de mise en relation a rencontré une erreur. Cette situation peut être due au fait que la filed'attente de sessions de jeu n'est pas accessible ou à une erreur interne.

Ressource : ConfigurationArn

Détails : type, tickets, ruleEvaluationMetrics , message,matchIdgameSessionInfo

Example

{ "version": "0", "id": "025b55a4-41ac-4cf4-89d1-f2b3c6fd8f9d", "detail-type": "GameLift Matchmaking Event", "source": "aws.gamelift", "account": "123456789012",

Version344

Amazon GameLift Manuel du développeurÉvénements de mise en relation

"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" }

Version345

Amazon GameLift Manuel du développeurVersions SDK

Notes de mise à jour pour GameLiftLes notes de mise à jour GameLift fournissent des détails sur les nouvelles fonctions, les nouvelles mises àjour et les nouveaux correctifs concernant le service. Il peut également s'agir de modifications aux élémentssuivants :

• Commandes de l'API GameLift du kit SDK AWS et de l'interface de ligne de commande• Kit SDK GameLift Server pour une utilisation avec des serveurs de jeux personnalisés et des serveurs de

jeu GameLift gérés• Kit SDK GameLift Client à utiliser avec Serveurs en temps réel• Console GameLift

Versions SDKLes onglets suivants répertorient toutes les versions GameLift avec des versions SDK. Il n'est pasnécessaire d'utiliser des versions comparables SDKs pour les intégrations de votre serveur et de votreclient de jeux, mais les versions plus anciennes d'un kit SDK peuvent ne pas prendre en charge totalementles dernières fonctionnalités d'un autre kit. Pour plus d'informations sur GameLift SDKs , consultezGameLift SDKs (p. 27) .

Note

Si vous chargez actuellement une build de serveur de jeux ou créez une ressource de build avecle kit SDK AWS à l'aide de Signature Version 2 pour l'authentification des demandes, vous devezpasser à Signature Version 4. - Signature Version 2 ne sera bientôt bientôt plus pris en charge,comme décrit dans AWS Signature Version 2 désactivé pour Amazon S3 .

Version actuelle

Version : AWSVersiond'SDK :

Version du kit SDKServer :

Version du clientSDK RealTime :

ParamètresrégionauxGameLift

2020-11-11 (p. 348) 1.8.36 ou versionultérieure

4.0.2 1.1.0 1.0.5

Versions précédentes

Version : AWSVersiond'SDK :

Version du kit SDKServer :

Version du clientSDK RealTime :

ParamètresrégionauxGameLift

2020-09-17 (p. 349) 1.8.36 ou versionultérieure

4.0.1 1.1.0 1.0.5

2020-08-27 (p. 351) 1.7.310 ou versionultérieure

4.0.0 1.1.0 1.0.5

2020-04-16 (p. 351) 1.7.310 ou versionultérieure

4.0.0 1.1.0 1.0.5

Version346

Amazon GameLift Manuel du développeurVersions SDK

Version : AWSVersiond'SDK :

Version du kit SDKServer :

Version du clientSDK RealTime :

ParamètresrégionauxGameLift

2020-04-02 (p. 350) 1.7.310 ou versionultérieure

3.4.0 1.1.0 1.0.0

2019-12-19 (p. 351) 1.7.249 ou versionultérieure

3.4.0 1.1.0 1.0.0

2019-11-14 (p. 351) 1.7.210 ou versionultérieure

3.4.0 1.1.0 1.0.0

2019-10-24 1.7.210 ou versionultérieure

3.4.0 1.1.0 1.0.0

2019-09-03 1.7.175 ou versionultérieure

3.4.0 1.1.0 1.0.0

2019-07-09 1.7.140 ou versionultérieure

3.3.0 1.0.0 1.0.0

25/04/2019 1.7.91 ou versionultérieure

3.3.0 1.0.0 1.0.0

2019-03-07 1.7.65 ou versionultérieure

3.3.0   1.0.0

2019-02-07 1.7.45 ou versionultérieure

3.3.0   1.0.0

14/12/2018 1.6.20 ou versionultérieure

3.3.0   1.0.0

2018-09-27 1.6.20 ou versionultérieure

3.2.1   1.0.0

2018-06-14 1.4.47 ou versionultérieure

3.2.1   1.0.0

2018-05-10 1.4.47 ou versionultérieure

3.2.1   1.0.0

15/02/2018 1.3.58 ou versionultérieure

3.2.1   1.0.0

08/02/2018 1.3.52 ou versionultérieure

3.2.0   1.0.0

2017-09-03 1.1.43 ou versionultérieure

3.1.7   1.0.0

16/08/2017 1.1.31 ou versionultérieure

3.1.7   1.0.0

2017-05-16 1.0.122 ou versionultérieure

3.1.5   1.0.0

2017-04-11 1.0.103 ou versionultérieure

3.1.5   1.0.0

Version347

Amazon GameLift Manuel du développeurNotes de mise à jour

Version : AWSVersiond'SDK :

Version du kit SDKServer :

Version du clientSDK RealTime :

ParamètresrégionauxGameLift

21/02/2017 1.0.72 ou versionultérieure

3.1.5    

2016-11-18 1.0.31 ou versionultérieure

3.1.0 (C++uniquement)

   

2016-10-13 1.0.17 ou versionultérieure

3.1.0 (C++uniquement)

   

01/09/2016 0.14.9 ou versionultérieure

3.1.0 (C++uniquement)

   

04/08/2016 0.12.16 ou versionultérieure

3.0.7 (C++uniquement)

   

Notes de mise à jourLes notes de mise à jour suivantes sont indiquées dans l'ordre chronologique. Les dernières mises à joursont répertoriées en premier. La première version de GameLift date de 2016. Pour les notes de mise àjour datées plus tôt que celles répertoriées ici, consultez les liens de date de publication dans VersionsSDK (p. 346).

11 novembre 2020 : Version mise à jour vers le kit SDK GameLiftServerAmazon GameLift Mise à jour du kit SDK Server pour résoudre les problèmes liés àStartMatchBackfill()

Date de parution : 11 novembre 2020

Mise à jour des versions du kit SDK :GameLift SDK Server 4.0.2

Le nouveau kit SDK Server version 4.0.2 corrige un problème connu avec la méthodeStartMatchBackfill() . Cette méthode renvoie désormais une réponse correcte à une requête derenvoi de correspondance.

Le problème n'a pas affecté le processus de renvoi de correspondance et il n'y a aucune modification à lafaçon dont cette fonctionnalité fonctionne. Le problème peut avoir impacté la messagerie et la gestion deserreurs des journaux pour les requêtes de renvoi de correspondance.

Téléchargez la dernière version du kit SDK GameLift Server sur la page Amazon GameLift Mise en route.

5 novembre 2020 : Nouvelles personnalisations FlexMatchd'algorithmeAmazon GameLift publie des options de personnalisation pour le processus de mise en FlexMatch relation.

Date de parution : 5 novembre 2020

FlexMatchLes utilisateurs ont désormais la possibilité d'ajuster les comportements par défaut suivants pourle processus de mise en relation. Ces personnalisations sont définies dans un ensemble de règles de miseen relation. Aucune modification n'est apportée à l' GameLift SDKs .

Version348

Amazon GameLift Manuel du développeurNotes de mise à jour

• Hiérarchisation des tickets de remplissage : Vous pouvez choisir d'augmenter ou de réduire la façondont les tickets de renvoi de correspondance sont hiérarchisés lors de la recherche de correspondancesacceptables. La hiérarchisation des tickets de remplissage est particulièrement utile lorsque la fonctionde remplissage automatique est activée. Utilisez la propriété d'algorithme backfillPriority .

• Pré-trier pour optimiser la cohérence et l'efficacité des correspondances : Configurez votre matchmakerpour trier au préalable le pool de tickets avant le traitement par lot des tickets pour évaluation. En triantau préalable les tickets en fonction des attributs de joueur clés, les parties qui en résultent ont tendanceà avoir des joueurs qui sont plus similaires dans ces attributs. Vous pouvez également renforcerl'efficacité du processus d'évaluation en effectuant un tri préalable sur les mêmes attributs qui sontutilisés dans les règles de correspondance. Utilisez la propriété d'algorithme sortByAttributes avecla strategy propriété définie sur « sorted ».

• Ajustez la manière dont les temps d'attente d'extension sont déclenchés : Choisissez entre déclencherdes extensions en fonction de l'âge du ticket le plus récent (par défaut) ou le plus ancien dans une partieincomplète. Le déclenchement sur le ticket le plus ancien a tendance à terminer les correspondancesplus rapidement, tandis que le déclenchement sur le ticket le plus récent entraîne une meilleure qualitéde correspondance. Utilisez la propriété d'algorithme expansionAgeSelection .

En savoir plus :

GameLift Guide du développeur

• Concevez un ensemble FlexMatch de règles :Personnalisation de l'algorithme decorrespondance (p. 159)

• ensemble FlexMatch de règles schéma (p. 324)Cette rubrique comporte désormais des informations deréférence détaillées pour chaque composant d'ensemble de règles.

17 septembre 2020 : GameLift met à jour le kit SDK ServerAmazon GameLift publie des mises à jour mineures sur le kit SDK Server

Date de parution : 17 septembre 2020

Mise à jour des versions du kit SDK :GameLift Kit SDK Server 4.0.1

Le nouveau kit SDK Server contient les mises à jour suivantes :

• Version d'API C# 4.0.1• La méthode TerminateGameSession() (p. 310) est obsolète. Remplacez par un appel à

ProcessEnding() (p. 306) pour mettre fin à une session de jeu et au processus serveur.• Un problème connu lié à la méthode GetInstanceCertificate () (p. 304) est résolu.• La méthode renvoie GetTerminationTime() (p. 305) désormais une valeur de type de

donnéesAwsDateTimeOutcome.• Version 3.4.1 de l'API C++

• La méthode TerminateGameSession() (p. 296) est obsolète. Remplacez par un appel àProcessEnding() (p. 291) pour mettre fin à une session de jeu et au processus serveur.

• Version 3.3.2 du plug-in Unreal Engine• La méthode TerminateGameSession() (p. 320) est obsolète. Remplacez par un appel à

ProcessEnding() (p. 318) pour mettre fin à une session de jeu et au processus serveur.• La méthode de rappel OnUpdateGameSession est ajoutée à FProcessParameters (p. 322) pour

prendre en charge le renvoi de correspondance.

Téléchargez la dernière version du kit SDK GameLift Server sur la page Amazon GameLift Mise en route.

Version349

Amazon GameLift Manuel du développeurNotes de mise à jour

27 août 2020 : GameLift FleetIQ pour l'hébergement de jeux avecAmazon EC2 (disponibilité générale)Amazon GameLift étend son FleetIQ pour l'optimisation des instances Spot.

Date de parution : 27 août 2020

Mise à jour des versions du kit SDK : Kit SDK AWS 1.8.36

La GameLift FleetIQ solution pour l'hébergement de jeux basé sur le cloud à faible coût sur Amazon EC2est désormais disponible pour les développeurs. GameLift FleetIQ offre aux développeurs la possibilitéd'héberger les serveurs de jeux directement sur les instances Amazon EC2 Spot en optimisant leur viabilitépour l'hébergement de jeux. Des développeurs de jeux peuvent utiliser GameLift FleetIQ avec de nouveauxjeux ou pour compléter la capacité des jeux existants. Cette solution prend en charge l'utilisation deconteneurs ou d'autres services AWS tels qu'AWS Shield et Amazon Elastic Container Service (AmazonECS).

Cette version de disponibilité générale inclut les mises à jour suivantes de la GameLift FleetIQ solution :

• La nouvelle opération d'API DescribeGameServerInstances renvoie des informations, y compris lestatut, sur toutes les instances actives d'un groupe GameLift FleetIQ de serveurs de jeux.

• La nouvelle stratégie d'équilibrage, ON_DEMAND_ONLY , configure un groupe de serveurs de jeux pourutiliser les instances à la demande uniquement. La stratégie d'équilibrage d'un groupe de serveurs dejeux peut être mise à jour à tout moment, ce qui permet de basculer entre les instances Spot et lesinstances à la demande si nécessaire.

• Les éléments d'aperçu suivants ont été supprimés pour une disponibilité générale :• Utilisation de clés de tri personnalisées pour les ressources du serveur de jeux. Les serveurs de jeux

peuvent être triés en fonction de l'horodatage d'enregistrement.• Balisage des ressources des ressources du serveur de jeux.

En savoir plus :

• Formation et certification AWS : Utilisation d'Amazon GameLift FleetIQ pour les serveurs de jeux• GameLift FleetIQ API Reference• GameLift FleetIQGuide (p. 218)• Annonces sur le blog Amazon Game Tech et le flux Nouveautés AWS

16 avril 2020 : GameLift met à jour le kit SDK Server pour Unity etUnreal EngineAmazon GameLift publie un kit SDK Server mis à jour pour prendre en charge le développement deserveurs de jeux avec Unity 2019 et Unreal Engine 4.24.

Date de parution : 16 avril 2020

Mise à jour des versions du kit SDK :GameLift SDK Server 4.0.0, GameLift Local 1.0.5

La dernière version du kit SDK GameLift Server contient les éléments mis à jour suivants :

• Kit SDK C# version 4.0.0 mis à jour pour Unity 2019• Plug-in Unreal version 3.3.1 mis à jour pour Unreal Engine 4.22, 4.23 et 4.24• GameLiftVersion locale 1.0.5 mise à jour pour tester les intégrations qui utilisent le kit SDK Server C# v

4.0.0

Version350

Amazon GameLift Manuel du développeurNotes de mise à jour

Téléchargez la dernière version du kit SDK GameLift Server sur la page Amazon GameLift Mise en route.

2 avril 2020 : GameLift FleetIQ disponible pour l'hébergement dejeux sur EC2 (version préliminaire publique)Amazon GameLift étend son FleetIQ pour l'optimisation des instances Spot.

Date de parution : 02 avril 2020

Mise à jour des versions du kit SDK : Kit SDK AWS 1.7.310

La fonction GameLift FleetIQ optimise la viabilité des instances Spot à faible coût pour une utilisationavec l'hébergement de jeux. Cette fonctionnalité est désormais étendue aux clients qui souhaitent gérerleurs ressources d'hébergement directement plutôt que via le service GameLift géré. Cette solution prenden charge l'utilisation de conteneurs ou d'autres services AWS tels qu'AWS Shield et Amazon ElasticContainer Service (Amazon ECS).

En savoir plus :

• GameTechArticle de blog surGameLift FleetIQ

19 décembre 2019 : Amélioration de la gestion des ressourcesAWS pour GameLift les ressourcesAmazon GameLift ajoute de nouvelles valeurs ARN et prise en charge du balisage

Date de parution : 19 décembre 2019

Mise à jour des versions du kit SDK : Kit SDK AWS 1.7.249

Vous pouvez désormais tirer parti des outils de gestion des ressources AWS avec les ressources GameLift.En particulier, toutes les ressources GameLift clés (builds, scripts, flottes, files d'attente de session de jeu,configurations de mise en relation et ensembles de règles de mise en relation) sont désormais affectées àdes valeurs ARN. Un ARN de ressource fournit un identificateur cohérent unique dans toutes les régions.Ils peuvent être utilisés pour créer des stratégies d'autorisations IAM spécifiques aux ressources. Lesressources se voient désormais attribuer un ARN ainsi qu'un identificateur de ressource préexistant, quin'est pas propre à la région.

De plus, les ressources GameLift prennent désormais en charge le balisage. Vous pouvez utiliser desbalises pour organiser les ressources, créer des stratégies d'autorisations IAM pour gérer l'accès à desgroupes de ressources, personnaliser les ventilations des coûts AWS, etc. Lors de la gestion des balisespour les ressources GameLift, utilisez les actions de l'API GameLift TagResource(), UntagResource()et ListTagsForResource().

En savoir plus :

• TagResourcedans la référence de l'API GameLift Amazon• Balisage des ressources AWS dans les Références générales AWS• Noms de ressources Amazon dans les Références générales AWS

14 novembre 2019 : Nouveaux CloudFormation modèles, mises àjour dans la région Chine (Beijing)Amazon GameLift élargit l'utilisation des CloudFormation modèles pour aider à automatiser la gestion desGameLift ressources

Version351

Amazon GameLift Manuel du développeurCompatibilité Lumberyard

Date de parution : 19 décembre 2019

Mise à jour des versions du kit SDK : Kit SDK AWS 1.7.210

CloudFormationModèles pourGameLift

Les ressources GameLift peuvent désormais être créées et gérées par le biais de AWS CloudFormation.Les AWS CloudFormation modèles existants pour Build et Fleet ont été mis à jour pour s'alignersur les ressources actuelles, et de nouveaux modèles sont désormais disponibles pour lesMatchmakingConfiguration ressources Script, Queue, et . MatchmakingRuleSet Les modèles simplifientconsidérablement la gestion des groupes de ressources AWS connexes, en particulier lors du déploiementde jeux sur plusieurs régions.AWS CloudFormation

En savoir plus :

• Référence de type de ressource Amazon GameLift dans le AWS CloudFormation Guide de l'utilisateur• Créer des ressources à l'aide de AWS CloudFormation (p. 94) dans le Amazon GameLift Guide du

développeur.

Compatibilité LumberyardPour les utilisateurs Amazon Lumberyard, le tableau suivant répertorie les versions du kit SDK GameLiftqui sont fournies avec le moteur de jeu Lumberyard ou compatibles avec lui.

Version Amazon Lumberyard : Sont fournies avec les versions du kit SDKGameLift :

1.4 à 1.5 (bêta) • SDK Server: 3.0 à 7• Kit SDK AWS : 0,1 à 16

1.6 à 1.7 (bêta) • SDK Server: 3.1.0• Kit SDK AWS : 4.9

1.8 à 1.14 (bêta) • SDK Server: 3.1.5• SDK AWS : 1.0.72 à 1.1.13

1.15 à 1.25 • SDK Server: 3.2.1• SDK AWS : 1.4.34 ou version ultérieure

1.26 et version ultérieure • SDK Server: 3.4.0• Kit SDK AWS : 1.7.310 ou version ultérieure

Version352

Amazon GameLift Manuel du développeur

Historique du document pourGameLift

Le tableau suivant décrit les modifications importantes apportées à la documentation Amazon GameLift.Pour de plus amples informations sur les versions des fonctions nouvelles et mises à jour, consultez lesNotes de mise à jour pour GameLift (p. 346).

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

16 avril 2020 Mises à jour :

• Nouvelle version du kitServer SDK – Le kitServer SDK mis à jourest désormais compatibleavec les derniers moteursUnity & Unreal.

Manuel du développeur:

• Mise à jour desdocuments sur ledéveloppement etl'utilisation du kitSDK Server avec desjeux Unity (p. 43) et Unreal (p. 40).

Server SDK 4.0.0

2 avril 2020 Nouvelle fonction

• FleetIQ en tant quesolution autonome(version préliminairepublique) – Les clientspeuvent utiliser GameLiftFleetIQ pour optimiserl'utilisation des instancesSpot EC2 avec leurhébergement de jeuxbasé sur le cloud existantou pour étendre oumigrer l'architectured'hébergement localeactuelle.

Manuel du développeur:

• Nouveau guide :• GameLift FleetIQGuide

(p. 218)

Référence d'API de service(kit SDK AWS) :

• Nouveau FleetIQopérations : Voir la listedes• TagResource ()• UntagResource• ListTagsForResource

AWS SDK : 2020-04-02

12 décembre 2019Mises à jour :

• Prise en charge de lagestion des ressourcesAWS – Les ressourcesGameLift clés ontdésormais des valeursARN et des balises deprise en charge.

Référence d'API de service(kit SDK AWS) :

• Nouvelles opérations debalisage :• TagResource ()• UntagResource• ListTagsForResource

• Nouveaux paramètres debalise et ARN pour cesressources GameLift :builds, scripts, flottes,files d'attente de sessionde jeu, configurations

AWS SDK : 2019-12-12

Version353

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

de mise en relation,ensembles de règles demise en relation.

15 novembre2019

Mises à jour :

• Prise en chargeétendue des modèlesCloudFormation pourGameLift – Les modèlesCloudFormation Build etFleet existants ont étémis à jour. Les nouveauxmodèles Script, Queue,MatchmakingConfigurationet MatchmakingRuleSetont été créés

Manuel du développeur:

• Nouvelle rubrique• Créer des ressources

à l'aide de AWSCloudFormation (p. 94)

 

24 octobre 2019Mises à jour :

• Prise en charge des typesd'instance Amazon Linux2 et Series 5 – Jeux hôtesutilisant les nouveauxtypes d'instance C5/M5/R5. Les serveurs dejeux peuvent désormaiss'exécuter sur AmazonLinux 2. Tous les serveursRealtime s'exécutentdésormais sur AmazonLinux 2.

Le Guide du développeur etles documents de référenced’API ont été mis à jourpour refléter les optionssupplémentaires.

Les mises à jour ont étépubliées dans les régionsau niveau mondial le24 octobre 2019, et dansla Région Chine (Beijing),exploitée par Sinnet, le15 novembre 2019.

AWS SDK : 24/10/2019

Version354

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

3 septembre 2019Nouvelles fonctions

• Génération de certificatsTLS – GameLift peutdésormais générerdes certificats TLSde niveau flotte pourla prise en chargede l'authentificationde serveur et duchiffrement des paquetsde données pour lesserveurs personnalisés etRealtime.

Manuel du développeur:

• Les rubriques suivantesont été mises à jour avecdes informations sur lescertificats TLS :• Hébergement de

serveurs de jeux (p. 4)• L'interaction entre les

clients et serveurs entemps réel (p. 11)

• Récupérer un certificatTLS (p. 47)

• Intégration d'un clientde jeu pour Serveurs entemps réel (p. 67)

Références des kits dedéveloppement logicielSDK :

• API de serviceGameLift, nouveauparamètre CreateFleet ()CertificateConfiguration

• Kit SDK GameLift Server,nouvelle opérationGetInstanceCertificate() C++ (p. 289) et C# (p. 304)

• Kit de développementlogiciel client Realtime,nouveau paramètre thesection called “Types dedonnées” (p. 276)

AWS SDK : 03/09/2019

Server SDK 3.4.0

Realtime Client SDK 1.1.0

Version355

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

9 juillet 2019 Nouvelles fonctions

• Prise en chargeFlexMatchpour les parties incluantde nombreux joueurs– Mise en relationétendue pour prendreen charge 200 joueurspar partie avec unnouvel algorithme plusrapide. Le remplissageautomatique des partiesoffre désormais un modeautomatique.

Manuel du développeur:

• Mise à jour ou extensiondes rubriques FlexMatchpour inclure desinformations sur lesparties à beaucoup dejoueurs :• Fonctionnement

d'Amazon GameLiftFlexMatch (p. 15)

• Concevoir un ensembleFlexMatch derègles (p. 158)

• ensemble FlexMatch derègles schéma (p. 324)

• Exemples FlexMatchd'ensembles derègles (p. 169)

• Renvoi dejeux existantsavecFlexMatch (p. 85)

• Concevoir unFlexMatchmatchmaker (p. 154)

Référence d'API de service(kit SDK AWS) :

• Opérations de l'API deconfiguration de miseen relation mises àjour pour prendre encharge le remplissageautomatique :• CreateMatchmakingConfiguration• UpdateMatchmakingConfiguration• StopMatchmaking

AWS SDK : 09/07/2019

Version356

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

25 avril 2019 Nouvelles fonctions

• Serveurs en temps réel– Utilisez Serveurs entemps réel avec unearchitecture intégrée deserveur de jeu de baseconçue pour déployervos jeux. Ajouter lalogique de serveur de jeupersonnalisée en fonctiondes besoins.

Manuel du développeur:

• Nouvelles rubriques surServeurs en temps réel :• Fonctionnement des

Serveurs en tempsréel (p. 9)

• Intégration de jeuxavec Amazon GameLiftServeurs en tempsréel (p. 66)

• Référence d'API declient Serveurs entemps réel (C#) (p. 270)

Référence d'API de service(kit SDK AWS) :

• Nouvelles opérationsd’API à gérer Serveurs entemps réel scripts : Créerun script, Descriptiondu script, Script demise à jour, Script desuppression, Scripts deliste

• Opérations de l'API deflotte mises à jour pouractiver le déploiementServeurs en temps réelavec des scripts.

AWS SDK : 25/04/2019

SDK Realtime Client 1.0.0

7 mars 2019 Nouvelles fonctions

• Accès sécurisé auxressources AWS –Autoriser les applicationsen cours d’exécutionsur un GameLift pourcommuniquer avec lesressources AWS quevous possédez.

Manuel du développeur:

• Nouvelle rubriqueCommuniquez avecd’autres ressources AWSde vos flottes (p. 49)sur les options d'accèssécurisé.

Référence d'API de service(kit SDK AWS) :

• CreateFleet etFleetAttributes – Ajout deInstanceRoleArn.

AWS SDK : 07/03/2019

Version357

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

7 février 2019 Nouvelles fonctions

• Suppression desensembles de règles decorrespondance

Manuel du développeur:

• Créer des ensemblesde règles de mise enrelation (p. 167) mis à jourpour la suppression desensembles de règles decorrespondance.

Référence d'API de service(kit SDK AWS) :

• DeleteMatchmakingRuleSet(nouveau)

AWS SDK : 07/02/2019

14 décembre2018

Mises à jour :

• Nouvelle version deSDK Server – SDKServer mis à jour estdésormais compatibleavec les derniers moteursUnity et Unreal, et peutêtre utilisé avec VisualStudio 15 2017.

• Renvoi FlexMatch prisen charge pour les jeuxUnreal Engine.

Manuel du développeur:

• Mise à jour desdocuments sur ledéveloppement etl'utilisation du kitSDK Server avec desjeux Unity (p. 43) et Unreal (p. 40).

• CompatibilitéLumberyard (p. 352) misà jour.

SDK Server:

• StartMatchBackfill(Unreal) (p. 319)(nouveau)

• StopMatchBackfill(Unreal) (p. 320)(nouveau)

SDK Server 3.3.0

27septembre2018

Nouvelles fonctions

• GameLift en Chine –Le service GameLift estdésormais disponibledans la région AWSChine (Beijing) gérée parSinnet.

Manuel du développeur:

• La nouvelle rubriqueUtilisation d'AmazonGameLift dans lesrégions AWS (p. 31)fournit des liens versdes informations surl'utilisation d'AWS enChine.

AWS SDK : 27/09/2018

Version358

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

14 juin 2018 Nouvelles fonctions

• Métriques de file d'attentepour FleetIQ – Utilisez lesmétriques FleetIQ poursuivre les performancesdes files d'attente.

Manuel du développeur:

• Cinq nouvelles métriquesde file d'attente ajoutées àMétriques GameLift pourles files d'attente (p. 207).

• Nouvelle rubriqueÉvaluer les métriquesde file d'attente (p. 148)pour optimiser lesperformances de la filed'attente.

10 mai 2018 Nouvelles fonctions

• Scalabilité automatiqueavec suivi de cible –Utilisez cette nouvelleméthode de mise àl'échelle pour fairecorrespondre la capacitéde la flotte à la demandedes joueurs.

• Activation/désactivationde la scalabilitéautomatique – Passez dela scalabilité automatiqueà la mise à l'échellemanuelle sans supprimerde stratégies de mise àl'échelle.

Manuel du développeur:

• La nouvelle sectionDimensionnementde la capacité d'uneflotte GameLift (p. 133)comporte toutes lesrubriques liées audimensionnement, ycompris la scalabilitéautomatique.

• Mise à jour de la sectionsur Dimensionnementde la capacitéd'une flotte (p. 6)dans la rubrique« Fonctionnementd'GameLift ».

Référence d'API de service(kit SDK AWS) :

• PutScalingPolicy (mis àjour avec de nouveauxexemples)

• StopFleetActions etStartFleetActions(nouveau)

AWS SDK : 10/05/2018

Version359

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

15 février 2018Nouvelles fonctions

• Instances Spot et FleetIQ– Utilisez la nouvellefonction FleetIQ avecles flottes d'instancesSpot pour diminuersignificativement voscoûts d'hébergement.

Manuel du développeur:

• Utilisation d'instancesSpot avecGameLift (p. 115) –Nouveau guide étape parétape pour l'utilisationd'un parc d'instancesSpot.

• Conception d'une filed'attente de session dejeu (p. 143) – Nouveauxconseils de conceptionpour la création etl'utilisation des filesd'attente, y compris avecles parcs d'instancesSpot.

• Mise à jour des rubriques

Choisir des ressourcesinformatiques (p. 111)

Déployer une flotteGameLift pourune build de jeupersonnalisée (p. 116)

Répondre à unenotification d’arrêt duprocessus serveur (p. 49)

Référence d'API de service(kit SDK AWS) :

• Ajout d'un nouveauparamètre FleetTypepour activer des parcsd'instances Spot :• CreateFleet• FleetAttributes• Evénement

SDK Server:

• GetTerminationTime (C++) (p. 290) (nouveau)

GetTerminationTime (C++) (p. 305) (nouveau)

AWS SDK : 15/02/2018

SDK Server : 3.2.1

Version360

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

8 février 2018 Nouvelles fonctions

• Renvoi FlexMatch –Utilisez FlexMatchpour injecter denouveaux joueurs dansdes sessions de jeucorrespondant qui sont encours.

• Recherche de sessionde jeu – Utilisez despropriétés de jeupersonnalisées

Manuel du développeur:

• Processus de mise enrelation (p. 16) – Mise àjour de la présentationdes fonctions FlexMatch.

• Renvoi de jeux existantsavecFlexMatch (p. 85)– Nouveau manuel deprocédures.

• Obtention de sessionsde jeu (p. 54) – Mise àjour des propriétés de jeupersonnalisées.

Référence d'API de service(kit SDK AWS) :

• StartMatchBackfill(nouveau)

• SearchGameSessions()(nouveau)

• GameSession (nouveau)

SDK Server:

• StartMatchBackfill (C++) (p. 294) (nouveau)

StartMatchBackfill (C++) (p. 308) (nouveau)

StopMatchBackfill (C++) (p. 295) (nouveau)

StopMatchBackfill (C++) (p. 309) (nouveau)

AWS SDK : 08/02/2018

SDK Server 3.2.0

Version361

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

3 septembre2017

Nouvelles fonctions

Appairage de VPC pour lesflottes Amazon GameLift– Vous pouvez désormaisutiliser l'appairage deVPC pour configurer desconnexions directes etprivées entre vos serveursde jeux Amazon GameLiftet d'autres ressources surAWS.

Manuel du développeur:

• Mise en réseauavec les ressourcesAWS (p. 9) – Obtenezplus d'informations surl'appairage de VPC et surson fonctionnement avecGameLift.

• Homologation VPCpour GameLift (p. 187)– En savoir plus surla configuration d'unappairage de VPC.

Référence API de service

• Nouvelles API pourl'appairage de VPC :• CreateVpcPeeringAuthorization• DescribeVpcPeeringAuthorizations• DeleteVpcPeeringAuthorization• CreateVpcPeeringConnection• DescribeVpcPeeringConnections• DeleteVpcPeeringConnection

• MatchmakingTicket –Ajout de EndTime etEstimatedWaitTime.

• La documentation deDescribeMatchmakinga été corrigée. Cetteopération peut êtreutilisée pour récupérer unmaximum de 10 tickets demise en relation.

AWS SDK : 01/09/2017

Version362

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

16 août 2017 Nouvelles fonctions

GameLift FlexMatch – Ajoutde l'activité de mise enrelation à vos jeux à l'aidede ce service de mise enrelation personnalisable.Avec FlexMatch, vouspouvez concevoir unensemble de règles baséessur les formats d'équipeet les caractéristiques dejoueur qui conviennent lemieux à votre jeu.

Manuel du développeur:

• Fonctionnementd'Amazon GameLiftFlexMatch (p. 15)– Obtenez plusd'informations surles fonctions clés deFlexMatch et sur sonfonctionnement.

• Ajout en cours de mise enrelation FlexMatch (p. 77)– En savoir plus sur lamanière de configurerFlexMatch et de lepersonnaliser en fonctionde votre jeu.

SDK Server:

• API GameLift Server –Nouvelles API pour gérerles ressources FlexMatchet démarrer de nouvellesparties avec la mise enrelation.

AWS SDK : 16/08/2017

SDK Server 3.1.7

Version363

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

16 mai 2017 Nouvelles fonctions

• Les métriques GameLiftsont désormais prisesen charge dans AmazonCloudWatch. Cela inclutla possibilité d'utiliser lesmétriques agrégées pourun groupe de flottes.

• Limitez les activationsde session de jeu sur lesinstances d'une flotte.

Mises à jour :

• Profitez des nouvellesmétriques pour une miseà l'échelle automatique.

• Utilisez l'interfaceutilisateur de la nouvelleconsole pour définir ledimensionnement de laflotte.

Manuel du développeur:

• Surveillance d'AmazonGameLift (p. 202) –Nouvelle section desurveillance, y comprisla liste des métriquesdisponibles dans laconsole GameLift et dansCloudWatch.

• Déployer une flotteGameLift pourune build de jeupersonnalisée (p. 116)et Gestion de vos flottesGameLift (p. 124) – Miseà jour des instructions decréation et mise à jour deconfigurations de flotte.

• Dimensionnerautomatiquement lacapacité de la flotte avecGameLift (p. 137) – Miseà jour des instructions surla configuration de la miseà l'échelle manuelle et dela scalabilité automatiquepour une flotte.

Référence API de service

• Nouveau paramètreMetricGroups ajouté pouractiver des métriquesagrégées :• CreateFleet• Propriété

UpdateFleetAttributespour

• FleetAttributes• RuntimeConfiguration

– Ajout de limitesd'activation de session dejeu.

AWS SDK : 16/05/2017

Version364

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

11 avril 2017 Nouvelles fonctions

• Amazon GameLift Local– Testez l'intégration devotre jeu localement.

• Files d'attente dessessions de jeu – Créezdes files d'attente multi-flottes et multi-régionspour placer de nouvellessessions de jeu avec lesmeilleures ressourcesd'hébergement possiblespour la latence, le coût etla résilience.

Mises à jour :

• Modifications apportéesà l'API Amazon GameLiftService (partie du kitde développementlogiciel (SDK) AWS) pouraméliorer la convivialité.

Manuel du développeur:

• Test del'intégration (p. 61)– Nouvelle rubriquesur la configuration etl'utilisation d'AmazonGameLift Local.

• Création d'une filed'attente (p. 149) – Mise àjour de la rubrique sur lacréation de files d'attente,avec de nouvellesinformations sur lesstratégies de latence dejoueurs.

Référence API de service

• PlayerLatencyPolicy(nouveau type dedonnées)

• PlacedPlayerSession(nouveau type dedonnées)

• GameSessionPlacement– Ajout deGameSessionId,IpAddress, Port etPlacedPlayerSessions.

• CreateGameSession– IdempotencyTokenremplaceGameSessionId.

• GameSessionQueue– Ajout deGameSessionQueueArn.

AWS SDK : 11/04/2017

GameLiftLocal 1.0.0

Version365

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

21 février 2017Nouvelles fonctions

• Prise en charge deplusieurs moteurs dejeux, dont Unreal Engine,Unity, ainsi que desmoteurs de jeux C++ etC# personnalisés

• Extension de la prise encharge du langage à C#pour le kit SDK Server

• Nouvelle création desession de jeu à l'aide deplacements de sessionsde jeu et de files d'attenteentre régions

• Prise en charge desdonnées de joueurpersonnalisées, avecdiffusion directe auserveur de jeux

Manuel du développeur:

• Architecture de jeu avecsolution GameLift gérée (p. 19) – Diagramme del'architecture.

• Moteurs de jeux etAmazon GameLift (p. 37)– Aide sur l'utilisationd'GameLift avecdifférents moteurs dejeux et instructions deconfiguration du plug-inpour Unreal Engine etUnity.

• Utilisation de filesd'attente sur plusieursrégions (p. 143) – Aidesur la création, la gestionet le suivi des métriquesdes files d'attente.

AWS SDK : 21/02/2017

SDK Server : 3.1.5

18 novembre 2016Nouvelles fonctions

• Accès distant auxinstances de flotteGameLift

Manuel du développeur:

• Nouvelles rubriques• Accès à distance aux

instances de flotteGameLift (p. 130) –Comment accéderet vous connecter àdistance aux instancesGameLift.

• Déboguer lesincidents de flotteGameLift (p. 127)– Conseils pour ledépannage desnouvelles flottes dontl'activation échoue.

Référence API de service

• Pour un accès distant :• GetInstanceAccess

(nouveau)• InstanceAccess

(nouveau)• InstanceCredentials

(nouveau)

AWS SDK : 18/11/2016

Version366

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

13 octobre 2016Nouvelles fonctions

• Protection de la créationdes ressources

• Accès aux donnéesd'instance

Mises à jour et corrections

• Aide supplémentaire pourLinux.

Manuel du développeur:

• Rubriques révisées :• Fonctionnement

d'un AmazonGameLift (p. 3) – Ajoutd'une descriptionde la protectiondes ressources etdescription plusdétaillée de la gestionde capacité.

• Ajout d'une aidespécifique à Linux :

Conditionner lesfichiers de version dejeu (p. 102) – Scriptsd'installation pourLinux.

Charger une build deserveur personnaliséesur GameLift (p. 101)– Nouveaux exemplesLinux.

Déployer une flotteGameLift pourune build de jeupersonnalisée (p. 116)– Nouvel exemple dechemin de lancementpour Linux.

Référence API de service

• CreateFleet etUpdateFleetAttributes– Nouveau paramètreResourceCreationLimitPolicy.

• ResourceCreationLimitPolicy(nouveau)

• CreateGameSession –Ajout de CreatorId.

• DescribeInstances(nouveau)

AWS SDK : 13/10/2016

Version367

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

1 septembre2016

Nouvelles fonctions

• Les serveurs de jeuxpeuvent désormaiss'exécuter sous Linux

Manuel du développeur:

• Nouvelles rubriques• GameLift SDKs (p. 27)

– Rubrique deréférence décrivanttous les kits SDKGameLift, y compris leslangues et les systèmesd'exploitation pris encharge.

Référence API de service

• De nouveaux paramètresde système d'exploitationont été ajoutés à ce quisuit :• upload-build (p. 101)

(interface de lignede commandeuniquement)

• CreateBuild()• Génération• FleetAttributes

AWS SDK : 01/09/2016

SDK serveur pour C++ :3.1.0

Version368

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

4 août 2016 Nouvelles fonctions

• Recherche de session dejeu

• Vérifications d'étatpersonnalisées

Mises à jour :

• Prise en charge étenduepour l'allocation decapacité (plusieursprocessus par instance deflotte)

• Kit SDK GameLiftServer pour C++désormais disponible entéléchargement

• Toutes les API pourl'intégration du clientde jeu sont maintenantincluses dans le AWSSDK.

Manuel du développeur:

• Nouvelles rubriques• Référence d'API

GameLift Serverpour C++ (p. 286) –Documentation deréférence complète.

• Exécution de plusieursprocessus sur une flotteGameLift (p. 113) –Présentation techniquede l'allocation decapacité et de laconfiguration d'uneflotte pour l'exécutionde plusieurs processus.

• Outils etressources (p. 29) –Liste exhaustive desoutils et ressources, enincluant la compatibilitéde version de kit SDK.

• Rubriques révisées :• Comment les joueurs

se connectent auxJeux (p. 13) – Larubrique étendue décritles fonctions relativesaux sessions de jeu,y compris la nouvellefonction de recherche.

• Ajouter GameLiftvers votre serveurde jeux (p. 46) – Lesétapes d'intégrationont été revues pourune utilisation avecla version 3.0.7 du kitSDK Server pour C++.

• Ajout d'AmazonGameLift à votre clientde jeu (p. 53) – Lesétapes d'intégration ontété revues pour uneutilisation avec le kitSDK AWS pour C++.

Référence API de service

AWS SDK : 04/08/2016

SDK serveur pour C++ :3.0.7

Version369

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

• SearchGameSessions()(nouveau)

Version370

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

28 juin 2016 Mises à jour :

• Nouvelles métriquesde statut du processusserveur

• Révision des processusrelatifs à l'allocation decapacité de flotte et auxparamètres de lancementdu serveur de jeux

• Révision des instructionsde package des versionsde génération

Manuel du développeur:

• Rubriques révisées :• Conditionner les

fichiers de versionde jeu (p. 102) – Ladescription indiquedésormais commentGameLift traite unfichier install.batdans une build de jeu.

• Déployer une flotteGameLift pourune build de jeupersonnalisée (p. 116)– Les instructionsde création d'uneflotte couvrentdésormais l'allocationde capacité à l'aided'une configurationd'exécution.

• Affichage des détailsd'une flotte (p. 196) etAffichage des donnéessur les sessions dejeu et les sessionsde joueur (p. 199)– Les descriptionsde page de consoleindiquent désormais lesmétriques en cours etdes onglets de mise àl'échelle.

• GameLift et interactionsclient/serveur dejeu (p. 58) – Lesdescriptions et lediagramme (p. 60)ont été corrigéspour utiliser desnoms de fonction derappel des exemples,et pour spécifierclairement que le rappelonProcessTerminate()faitréférence à l'arrêt d'unserveur de jeux, et nonune session de jeu.

Référence API de service

AWS SDK : 28/06/2016

Version371

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

• Pour la nouvelle allocationde capacité :• CreateFleet()

– Ajout d'uneconfigurationd'exécution.

• DescribeRuntimeConfiguration(nouveau)

• UpdateRuntimeConfiguration(nouveau)

• Pour le processus delancement du serveur dejeux :• GameSession – Ajout

d'un numéro de port.PlayerSession –Ajout d'un numéro deport.

• Pour les métriques destatut :• FleetUtilization

– Ajout d'un nouveaunombre pour lesprocessus serveuractifs.

Version372

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

10 mars 2016 Nouvelles fonctions

• Scalabilité automatique• Protection d'une session

de jeu• Limites de capacité de

flotte

Manuel du développeur:

• Nouvelles rubriques• Dimensionner

automatiquement lacapacité de la flotteavec GameLift (p. 137)– Comment configureret gérer des stratégiesde scalabilitéautomatique.

• Réglage manuel de lacapacité d'une flotteGameLift (p. 135) –Comment modifier lenombre d'instancesdans une flotte et définirdes limites.

• Fonctionnement d'unAmazon GameLift (p. 3)– Présentationtechnique de la façondont GameLift gère ledéploiement de jeuxsur des ressourcesvirtuelles.

• Rubriques révisées :• Déployer une flotte

GameLift pourune build de jeupersonnalisée (p. 116)– Révision desinformations relativesà l'inclusion deparamètres pourla protection d'unesession de jeu etune mise à l'échelleappropriée.

• Autres modifications :• Le didacticiel

Lumberyard-GameLifta été déplacé dans lerépertoire GameDevTutorials.

Référence API de service

• Pour la scalabilitéautomatique :• () PutScalingPolicy

AWS SDK 2016-03-10

Version373

Amazon GameLift Manuel du développeur

<Date> Modification Mises à jour de ladocumentation

Versions d'API mises à jour

• DescribeScalingPolicies• DeleteScalingPolicy

• Pour la protection d'unesession de jeu :• DescribeGameSessionDetails• CreateFleet (révisée)• UpdateFleetAttributes

(révisée)• DescribeFleetAttributes

(révisée)• UpdateGameSession

(révisée)• Pour les limites de

capacité de flotte :• UpdateFleetCapacity

(révisée)• DescribeFleetCapacity

(révisée)

9 février 2016 Lancement de service Manuel du développeuret Référence API pour leservice GameLift publiédans AWS.

AWS SDK 2016-02-09

Version374

Amazon GameLift Manuel du développeur

Glossaire AWSPour la terminologie AWS la plus récente, consultez le Glossaire AWS dans le document AWS GeneralReference.

Version375

Amazon GameLift Manuel du développeur

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenud'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Versionccclxxvi