本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 借助 Amazon GameLift Servers 插件完成 Unreal 或 Unity 游戏的准备工作
Amazon GameLift Servers 插件是 Unreal 或 Unity 游戏引擎的全功能附加组件。它会指导您完成通过 Amazon GameLift Servers 部署游戏进行托管的基本步骤。利用该插件的工具集和工作流程，您可以在游戏引擎开发环境中工作，以便让游戏服务器做好托管准备、在本地计算机上设置托管以进行测试、创建简单的后端服务，以及将游戏服务器部署到基于云的托管式托管。
使用该插件可体验使用 Amazon GameLift Servers 以及快速启动并运行游戏托管解决方案。您可以使用示例游戏资产或您自己的游戏项目。该插件可自动执行多个步骤，让您可以快速构建简单高效的解决方案。完成插件的引导式工作流程后，您将能够通过 Amazon GameLift Servers 将游戏客户端连接到托管的实时游戏会话。使用该插件创建简单的托管解决方案后，您就可以根据游戏需求自定义解决方案。
该插件适用于以下游戏引擎：
+ Unreal Engine
+ Unity
该插件包含每个游戏引擎的以下组件：
+ 游戏引擎编辑器的插件模块。安装插件后，新的主菜单按钮可让您访问 Amazon GameLift Servers 的功能。
+ 适用于具有客户端功能的 Amazon GameLift Servers 服务 API 的库。
+ 适用于 Amazon GameLift Servers 服务器 SDK（版本 5）的库。
+ 用于测试服务器集成的示例资产。
+ 以 CloudFormation 模板形式的可编辑配置，用于定义您的游戏服务器解决方案。
**Topics**
+ [插件工作流](#getting-started-plugin-workflow)
+ [Amazon GameLift Servers虚幻引擎插件](unreal-plugin.md)
+ [Amazon GameLift Servers适用于 Unity 的插件（服务器 SDK 5.x）](unity-plug-in.md)
+ [适用于 Unity 的 Amazon GameLift Servers 插件（服务器 SDK 4）](unity-plug-in-sdk4.md)
## 插件工作流
以下步骤描述了在 Amazon GameLift Servers 上准备和部署游戏项目的典型路径。您可以通过游戏引擎编辑器和游戏代码来完成这些步骤。
1. 创建用户个人资料，链接到您的 AWS 账户用户，并向访问凭证提供使用权限Amazon GameLift Servers。
1. 设置插件在托管解决方案中使用的相关 AWS 资源（称为 “引导”）。
1. 将服务器代码添加到您的项目，以便在正在运行的游戏服务器和 Amazon GameLift Servers 服务之间建立通信。
1. 将客户端代码添加到您的项目，让游戏客户端向 Amazon GameLift Servers 发送请求，以便启动新游戏会话，然后连接到这些会话。
1. 使用 Anywhere 工作流程将本地工作站设置为 Anywhere 计算，并托管游戏服务器。通过插件在本地启动游戏服务器和客户端，连接到游戏会话，然后测试集成。
1. 使用托管 EC2 工作流程将游戏服务器上传到Amazon GameLift Servers并部署简单但完整的云托管解决方案。通过插件在本地启动游戏客户端，请求一个游戏会话并连接到该会话，然后开始玩游戏。
在插件中工作时，您将创建和使用 AWS 资源，这些操作可能会对正在使用的 AWS 账户产生费用。如果您不熟悉 AWS，这些操作可能包含在[AWS 免费套餐](https://aws.amazon.com/free/)中。
# Amazon GameLift Servers虚幻引擎插件
此插件将 Amazon GameLift Servers C\$1\$1 服务器 SDK 和工具添加到 UE 编辑器中。使用引导式 UI 工作流程将服务器 SDK 功能集成到您的游戏项目中，并为您的游戏服务器部署 Amazon GameLift Servers 托管解决方案。
利用插件，您可以构建一个基本的托管解决方案，然后根据需要进行优化和自定义。设置以本地工作站为主机的 Amazon GameLift Servers Anywhere 实例集。对于使用托管式 EC2 或托管式容器实例集的云托管，请使用完整的解决方案部署游戏服务器，以便管理游戏会话请求和客户端连接。
**Topics**
+ [为 Unreal 游戏项目安装插件](#unreal-plugin-install)
+ [后续步骤：自定义游戏托管解决方案](#unreal-plugin-next-steps)
+ [虚幻引擎插件：设置 AWS 用户个人资料](unreal-plugin-profiles.md)
+ [适用于 Unreal 的插件：集成游戏代码](unreal-plugin-integrate.md)
+ [适用于 Unreal 的插件：使用 Amazon GameLift Servers Anywhere 在本地托管游戏](unreal-plugin-anywhere.md)
+ [适用于 Unreal 的插件：将游戏部署到托管式 EC2 实例集](unreal-plugin-ec2.md)
+ [适用于 Unreal 的插件：将游戏部署到托管式容器实例集](unreal-plugin-container.md)
## 为 Unreal 游戏项目安装插件
**[从以下地址获取虚幻引擎Amazon GameLift Servers插件 GitHub](https://github.com/amazon-gamelift/amazon-gamelift-plugin-unreal)**
有关如何在虚幻编辑器中为游戏项目安装插件的信息，请参阅 GitHub 存储库自述文件。
该插件包括以下组件：
+ UE 编辑器的插件模块。安装插件后，新的主菜单按钮可让您访问 Amazon GameLift Servers 的功能。
+ 适用于 Amazon GameLift Servers 服务 API 的 C\$1\$1 库。在客户端后端服务中使用 API 功能来帮助游戏客户端请求游戏会话和 send/retrieve 游戏会话信息。
+ 适用于 Amazon GameLift Servers 服务器 SDK（版本 5）的 Unreal 库。在游戏服务器代码中使用服务器 SDK 来管理托管游戏服务器进程与 Amazon GameLift Servers 服务之间的通信。
+ 测试内容，包括启动游戏地图和两张测试地图，其中包含用于测试服务器集成的基本蓝图和用户界面元素。
+ 插件在部署游戏服务器进行托管时使用的 CloudFormation 模板形式的可编辑配置。
此插件使用 AWS CloudFormation 模板为常见游戏场景部署托管解决方案。您可以使用提供的这些解决方案，也可以根据游戏需要对其进行自定义。
## 后续步骤：自定义游戏托管解决方案
使用该插件的指导式工作流程可以很好地快速启动并运行 Amazon GameLift Servers 托管解决方案。借助该插件，您可以为解决方案的每个组件设置基本版本。
准备就绪后，您可以通过自定义每个组件，在此基本解决方案的基础上进行构建，并可以在为游戏发布做准备时对解决方案进行微调。考虑以下选项：
+ 修改实例集和实例集配置。请参阅[托管资源自定义](fleets-design.md)。
+ 自定义游戏会话队列配置。请参阅[自定义游戏会话队列](queues-design.md)。
+ 向游戏服务器和游戏客户端添加功能。请参阅[将游戏服务器与 Amazon GameLift Servers 集成](gamelift-sdk-server.md)和[集成 Amazon GameLift Servers 游戏客户端功能](gamelift-sdk-client-api.md)。
+ 自定义后端服务。请参阅[为 Amazon GameLift Servers 构建后端服务](gamelift_quickstart_customservers_designbackend.md)。
+ 设置自动容量扩展以满足预期的玩家需求。请参阅[利用 Amazon GameLift Servers 扩展游戏托管容量](fleets-manage-capacity.md)。
+ 设置托管可观测性工具，包括分析和日志记录。请参阅[监控 Amazon GameLift Servers](monitoring-overview.md)。
+ 使用[基础设施即代码（IaC）](https://docs.aws.amazon.com/whitepapers/latest/introduction-devops-aws/infrastructure-as-code.html)自动执行部署。该插件针对托管解决方案的指导式工作流程使用 AWS CloudFormation 模板。您可以根据需要对模板进行自定义。请参阅[使用管理Amazon GameLift Servers托管资源 CloudFormation](resources-cloudformation.md)。
**Topics**
+ [为 Unreal 游戏项目安装插件](#unreal-plugin-install)
+ [后续步骤：自定义游戏托管解决方案](#unreal-plugin-next-steps)
+ [虚幻引擎插件：设置 AWS 用户个人资料](unreal-plugin-profiles.md)
+ [适用于 Unreal 的插件：集成游戏代码](unreal-plugin-integrate.md)
+ [适用于 Unreal 的插件：使用 Amazon GameLift Servers Anywhere 在本地托管游戏](unreal-plugin-anywhere.md)
+ [适用于 Unreal 的插件：将游戏部署到托管式 EC2 实例集](unreal-plugin-ec2.md)
+ [适用于 Unreal 的插件：将游戏部署到托管式容器实例集](unreal-plugin-container.md)
# 虚幻引擎插件：设置 AWS 用户个人资料
安装插件后，使用有效的 AWS 帐户设置用户个人资料。您可以在插件中维护多个配置文件，但一次只能选择一个配置文件。每当使用插件时，请选择要使用的配置文件。每个工作流程页面都会显示当前选择的配置文件。
维护多个配置文件使您能够在不同的托管部署之间切换。例如，您可以设置使用相同 AWS 账户但部署到不同 AWS 区域的配置文件。或者，您可以使用不同的 AWS 帐户、用户和权限集来设置配置文件。
**注意**
如果您已在工作站上安装了 AWS CLI 并且已经配置了配置文件，则该Amazon GameLift Servers插件将对其进行检测并将其列为现有配置文件。该插件会自动选择任何名为 `[default]` 的配置文件。您可以使用现有配置文件或创建新的配置文件。
必须启动所有配置文件才能在您的账户用户下设置一些必需的 AWS 资源。
**管理您的 AWS 个人资料**
1. 在 Unreal 编辑器主工具栏中，选择 Amazon GameLift Servers 菜单，然后选择 **AWS 访问凭证**。此操作会打开 Amazon GameLift Servers 插件并转到**设置您的用户配置文件**页面。
1. 使用按钮创建新 AWS 帐户或为已有的 AWS 帐户设置用户个人资料。
1. 如果您还没有用户配置文件，系统会提示您输入配置文件详细信息并创建新的配置文件。提供以下信息：
+ 一个 AWS 账户。如果您创建了一个新 AWS 帐户，请使用链接 AWS 管理控制台 并按照提示进行操作。有关更多详细信息，请参阅[创建 AWS 账户](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-creating.html)。
+ 有权使用Amazon GameLift Servers和其他必需 AWS 服务的 AWS 用户。有关设置具有Amazon GameLift Servers权限的 AWS Identity and Access Management (IAM) 用户以及使用长期证书进行编程访问的说明，请参阅[设置 AWS 用户账户](setting-up-aws-login.md)。
+ 您的 AWS 用户的凭证。这些证书由 AWS 访问密钥 ID 和 AWS 密钥组成。有关更多详细信息，请参阅[获取访问密钥](https://docs.aws.amazon.com/cli/latest/userguide/cli-authentication-user.html#cli-authentication-user-get)。
+ AWS 区域。这是您要在其中创建托管 AWS 资源的地理位置。在开发过程中，我们建议使用靠近您的实际位置的区域。从[支持的区域列表中选择一个 AWS 区域](https://docs.aws.amazon.com/general/latest/gr/gamelift.html)。
1. 如果插件检测到现有配置文件，则会显示可用配置文件列表。从列表中选择现有配置文件，或选择**添加其他配置文件**以创建新的配置文件。
## 引导用户配置文件
所有配置文件必须进行引导才能与 Amazon GameLift Servers 插件搭配使用。引导会创建特定于该配置文件的 Amazon S3 存储桶。它用于存储项目配置、构建构件和其他依赖项。存储桶不会在其他配置文件之间共享。
Bootstrapp涉及创建新 AWS 资源，并且可能会产生成本。
**要引导您的配置文件，请执行以下操作：**
1. 在 **AWS 访问凭证**页面上，检查要使用的用户配置文件的引导状态。如果配置文件的引导状态为“非活动”，并且未列出 S3 存储桶，则需要引导配置文件。
1. 选择要使用的配置文件，然后选择**引导配置文件**。
1. 等待引导状态变为“活动”。这可能需要几分钟的时间。
# 适用于 Unreal 的插件：集成游戏代码
在将游戏服务器部署到实例集之前，您需要对游戏代码进行一系列更新，并将游戏组件打包以供 Amazon GameLift Servers 服务使用。
本主题将介绍进行最小集成的步骤。要进行服务器集成，请使用提供的代码示例更新项目的游戏模式。
+ [设置生成包目标和模块规则](#unreal-plugin-anywhere-integrate-setup)
+ [更新游戏服务器代码](#unreal-plugin-anywhere-integrate-simple-server)
+ [整合客户端游戏地图](#unreal-plugin-anywhere-integrate-simple-client)
+ [打包游戏组件](#unreal-plugin-anywhere-integrate-build)
## 设置生成包目标和模块规则
修改您的游戏项目文件，以正确生成可与 Amazon GameLift Servers 搭配使用的生成包组件。
**要添加客户端和服务器生成包目标，请执行以下操作：**
1. 打开游戏项目的代码文件并找到 `.../Games/[your application name]Source/[your application name]Target.cs` 文件。示例：`.../Source/GameLiftUnrealAppTarget.cs`。（如果您使用 Visual Studio，请打开项目的 `.sln` 文件。）
1. 复制此文件，以在 `Source/` 目录中创建两个新的目标文件。
+ 客户端目标：将新文件重命名为 `[your application name]Client.Target.cs`。编辑内容以更新类名称和目标类型值，如以下示例代码所示：
```
using UnrealBuildTool;
using System.Collections.Generic;
public class GameLiftUnrealAppClientTarget : TargetRules
{
public GameLiftUnrealAppClientTarget ( TargetInfo Target ) : base ( Target )
{
Type = TargetType.Client;
DefaultBuildSettings = BuildSettingsVersion.V2;
IncludeOrderVersion = EngineIncludeOrderVersion.Unreal5_1;
ExtraModuleNames.Add( "GameLiftUnrealApp");
}
}
```
+ 服务器目标：将新文件重命名为 `[your application name]Server.Target.cs`。编辑内容以更新类名称和目标类型值，如以下示例代码所示：
```
using UnrealBuildTool;
using System.Collections.Generic;
public class GameLiftUnrealAppServerTarget : TargetRules
{
public GameLiftUnrealAppServerTarget ( TargetInfo Target ) : base ( Target )
{
Type = TargetType.Server;
DefaultBuildSettings = BuildSettingsVersion.V2;
IncludeOrderVersion = EngineIncludeOrderVersion.Unreal5_1;
ExtraModuleNames.Add( "GameLiftUnrealApp");
}
}
```
1. 重新生成您的项目文件。如果您使用 Visual Studio，可以右键单击游戏项目的 `.uproject` 文件，然后选择**生成 Visual Studio 项目文件**。
**要更新游戏项目模块规则，请执行以下操作：**
更新游戏项目的模块规则，使其依赖于插件。
1. 打开游戏项目的代码文件并找到 `.../Games/[your application name]Source/[your application name].Build.cs` 文件。示例：`.../Source/GameLiftUnrealApp.Build.cs`。（如果您使用 Visual Studio，请打开项目的 `.sln` 文件。）
1. 找到 `ModuleRules` 类并进行更新，如以下示例代码所示：
```
using UnrealBuildTool;
public class GameLiftUnrealApp : ModuleRules
{
public GameLiftUnrealApp ( ReadOnlyTargetRules Target ) : base ( Target )
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "EnhancedInput" });
// Add the following section
if (Target.Type == TargetType.Server)
{
PublicDependencyModuleNames.Add("GameLiftServerSDK");
}
else
{
PublicDefinitions.Add("WITH_GAMELIFT=0");
}
bEnableExceptions = true;
}
}
```
1. 创建新的目标文件并修改模块规则后，重新构建您的游戏项目。
## 更新游戏服务器代码
更新您的游戏服务器代码，以实现游戏服务器进程与 Amazon GameLift Servers 服务之间的通信。您的游戏服务器必须能够响应来自 Amazon GameLift Servers 的请求，例如启动和停止新的游戏会话。
**为 Amazon GameLift Servers 添加服务器代码**
1. 在代码编辑器中，打开游戏项目的解决方案（`.sln`）文件，该文件通常位于项目根文件夹中。例如：`GameLiftUnrealApp.sln`。
1. 打开解决方案后，找到项目游戏模式头文件：`[project-name]GameMode.h` 文件。例如：`GameLiftUnrealAppGameMode.h`。
1. 更改头文件以使其与以下代码保持一致。请务必用您自己的项目名称替换 GameLiftServer “”。这些更新特定于游戏服务器；我们建议您备份原始游戏模式文件副本，以供客户端使用。
### gameMode.h 示例代码
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/GameModeBase.h"
#include "GameLiftUnrealAppGameMode.generated.h"
struct FProcessParameters;
DECLARE_LOG_CATEGORY_EXTERN(GameServerLog, Log, All);
UCLASS(minimalapi)
class AGameLiftUnrealAppGameMode : public AGameModeBase
{
GENERATED_BODY()
public:
AGameLiftUnrealAppGameMode();
protected:
virtual void BeginPlay() override;
private:
void InitGameLift();
private:
TSharedPtr ProcessParameters;
};
```
+ 打开相关的源文件 `[project-name]GameMode.cpp` 文件（例如 `GameLiftUnrealAppGameMode.cpp`）。更改代码以使其与以下示例代码保持一致。请务必用您自己的项目名称替换 GameLiftUnrealApp “”。这些更新特定于游戏服务器；我们建议您备份原始文件副本，以供客户端使用。
以下示例代码展示了如何添加服务器与 Amazon GameLift Servers 集成所需的最少元素：
+ 初始化 Amazon GameLift Servers API 客户端。Amazon GameLift Servers Anywhere 实例集需要使用服务器参数进行 `InitSDK()` 调用。当您连接到 Anywhere 实例集时，插件会将服务器参数存储为控制台参数。示例代码可以在运行时访问这些值。
+ 实现所需的回调函数以响应 Amazon GameLift Servers 服务的请求，包括 `OnStartGameSession`、`OnProcessTerminate` 和 `onHealthCheck`。
+ 准备好托管游戏会话时，请使用指定端口调用 `ProcessReady()` 以通知 Amazon GameLift Servers 服务。
### 游戏服务器示例代码
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
#include "GameLiftUnrealAppGameMode.h"
#include "UObject/ConstructorHelpers.h"
#include "Kismet/GameplayStatics.h"
#if WITH_GAMELIFT
#include "GameLiftServerSDK.h"
#include "GameLiftServerSDKModels.h"
#endif
#include "GenericPlatform/GenericPlatformOutputDevices.h"
DEFINE_LOG_CATEGORY(GameServerLog);
AGameLiftUnrealAppGameMode::AGameLiftUnrealAppGameMode() :
ProcessParameters(nullptr)
{
// Set default pawn class to our Blueprinted character
static ConstructorHelpers::FClassFinder PlayerPawnBPClass(TEXT("/Game/ThirdPerson/Blueprints/BP_ThirdPersonCharacter"));
if (PlayerPawnBPClass.Class != NULL)
{
DefaultPawnClass = PlayerPawnBPClass.Class;
}
UE_LOG(GameServerLog, Log, TEXT("Initializing AGameLiftUnrealAppGameMode..."));
}
void AGameLiftUnrealAppGameMode::BeginPlay()
{
Super::BeginPlay();
#if WITH_GAMELIFT
InitGameLift();
#endif
}
void AGameLiftUnrealAppGameMode::InitGameLift()
{
#if WITH_GAMELIFT
UE_LOG(GameServerLog, Log, TEXT("Calling InitGameLift..."));
// Getting the module first.
FGameLiftServerSDKModule* GameLiftSdkModule = &FModuleManager::LoadModuleChecked(FName("GameLiftServerSDK"));
//Define the server parameters for a GameLift Anywhere fleet. These are not needed for a GameLift managed EC2 fleet.
FServerParameters ServerParametersForAnywhere;
bool bIsAnywhereActive = false;
if (FParse::Param(FCommandLine::Get(), TEXT("glAnywhere")))
{
bIsAnywhereActive = true;
}
if (bIsAnywhereActive)
{
UE_LOG(GameServerLog, Log, TEXT("Configuring server parameters for Anywhere..."));
// If GameLift Anywhere is enabled, parse command line arguments and pass them in the ServerParameters object.
FString glAnywhereWebSocketUrl = "";
if (FParse::Value(FCommandLine::Get(), TEXT("glAnywhereWebSocketUrl="), glAnywhereWebSocketUrl))
{
ServerParametersForAnywhere.m_webSocketUrl = TCHAR_TO_UTF8(*glAnywhereWebSocketUrl);
}
FString glAnywhereFleetId = "";
if (FParse::Value(FCommandLine::Get(), TEXT("glAnywhereFleetId="), glAnywhereFleetId))
{
ServerParametersForAnywhere.m_fleetId = TCHAR_TO_UTF8(*glAnywhereFleetId);
}
FString glAnywhereProcessId = "";
if (FParse::Value(FCommandLine::Get(), TEXT("glAnywhereProcessId="), glAnywhereProcessId))
{
ServerParametersForAnywhere.m_processId = TCHAR_TO_UTF8(*glAnywhereProcessId);
}
else
{
// If no ProcessId is passed as a command line argument, generate a randomized unique string.
FString TimeString = FString::FromInt(std::time(nullptr));
FString ProcessId = "ProcessId_" + TimeString;
ServerParametersForAnywhere.m_processId = TCHAR_TO_UTF8(*ProcessId);
}
FString glAnywhereHostId = "";
if (FParse::Value(FCommandLine::Get(), TEXT("glAnywhereHostId="), glAnywhereHostId))
{
ServerParametersForAnywhere.m_hostId = TCHAR_TO_UTF8(*glAnywhereHostId);
}
FString glAnywhereAuthToken = "";
if (FParse::Value(FCommandLine::Get(), TEXT("glAnywhereAuthToken="), glAnywhereAuthToken))
{
ServerParametersForAnywhere.m_authToken = TCHAR_TO_UTF8(*glAnywhereAuthToken);
}
FString glAnywhereAwsRegion = "";
if (FParse::Value(FCommandLine::Get(), TEXT("glAnywhereAwsRegion="), glAnywhereAwsRegion))
{
ServerParametersForAnywhere.m_awsRegion = TCHAR_TO_UTF8(*glAnywhereAwsRegion);
}
FString glAnywhereAccessKey = "";
if (FParse::Value(FCommandLine::Get(), TEXT("glAnywhereAccessKey="), glAnywhereAccessKey))
{
ServerParametersForAnywhere.m_accessKey = TCHAR_TO_UTF8(*glAnywhereAccessKey);
}
FString glAnywhereSecretKey = "";
if (FParse::Value(FCommandLine::Get(), TEXT("glAnywhereSecretKey="), glAnywhereSecretKey))
{
ServerParametersForAnywhere.m_secretKey = TCHAR_TO_UTF8(*glAnywhereSecretKey);
}
FString glAnywhereSessionToken = "";
if (FParse::Value(FCommandLine::Get(), TEXT("glAnywhereSessionToken="), glAnywhereSessionToken))
{
ServerParametersForAnywhere.m_sessionToken = TCHAR_TO_UTF8(*glAnywhereSessionToken);
}
UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_YELLOW);
UE_LOG(GameServerLog, Log, TEXT(">>>> WebSocket URL: %s"), *ServerParametersForAnywhere.m_webSocketUrl);
UE_LOG(GameServerLog, Log, TEXT(">>>> Fleet ID: %s"), *ServerParametersForAnywhere.m_fleetId);
UE_LOG(GameServerLog, Log, TEXT(">>>> Process ID: %s"), *ServerParametersForAnywhere.m_processId);
UE_LOG(GameServerLog, Log, TEXT(">>>> Host ID (Compute Name): %s"), *ServerParametersForAnywhere.m_hostId);
UE_LOG(GameServerLog, Log, TEXT(">>>> Auth Token: %s"), *ServerParametersForAnywhere.m_authToken);
UE_LOG(GameServerLog, Log, TEXT(">>>> Aws Region: %s"), *ServerParametersForAnywhere.m_awsRegion);
UE_LOG(GameServerLog, Log, TEXT(">>>> Access Key: %s"), *ServerParametersForAnywhere.m_accessKey);
UE_LOG(GameServerLog, Log, TEXT(">>>> Secret Key: %s"), *ServerParametersForAnywhere.m_secretKey);
UE_LOG(GameServerLog, Log, TEXT(">>>> Session Token: %s"), *ServerParametersForAnywhere.m_sessionToken);
UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_NONE);
}
UE_LOG(GameServerLog, Log, TEXT("Initializing the GameLift Server..."));
//InitSDK will establish a local connection with GameLift's agent to enable further communication.
FGameLiftGenericOutcome InitSdkOutcome = GameLiftSdkModule->InitSDK(ServerParametersForAnywhere);
if (InitSdkOutcome.IsSuccess())
{
UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_GREEN);
UE_LOG(GameServerLog, Log, TEXT("GameLift InitSDK succeeded!"));
UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_NONE);
}
else
{
UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_RED);
UE_LOG(GameServerLog, Log, TEXT("ERROR: InitSDK failed : ("));
FGameLiftError GameLiftError = InitSdkOutcome.GetError();
UE_LOG(GameServerLog, Log, TEXT("ERROR: %s"), *GameLiftError.m_errorMessage);
UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_NONE);
return;
}
ProcessParameters = MakeShared();
//When a game session is created, Amazon GameLift Servers sends an activation request to the game server and passes along the game session object containing game properties and other settings.
//Here is where a game server should take action based on the game session object.
//Once the game server is ready to receive incoming player connections, it should invoke GameLiftServerAPI.ActivateGameSession()
ProcessParameters->OnStartGameSession.BindLambda([=](Aws::GameLift::Server::Model::GameSession InGameSession)
{
FString GameSessionId = FString(InGameSession.GetGameSessionId());
UE_LOG(GameServerLog, Log, TEXT("GameSession Initializing: %s"), *GameSessionId);
GameLiftSdkModule->ActivateGameSession();
});
//OnProcessTerminate callback. Amazon GameLift Servers will invoke 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 Amazon GameLift Servers we are indeed going to shutdown.
ProcessParameters->OnTerminate.BindLambda([=]()
{
UE_LOG(GameServerLog, Log, TEXT("Game Server Process is terminating"));
// First call ProcessEnding()
FGameLiftGenericOutcome processEndingOutcome = GameLiftSdkModule->ProcessEnding();
// Then call Destroy() to free the SDK from memory
FGameLiftGenericOutcome destroyOutcome = GameLiftSdkModule->Destroy();
// Exit the process with success or failure
if (processEndingOutcome.IsSuccess() && destroyOutcome.IsSuccess()) {
UE_LOG(GameServerLog, Log, TEXT("Server process ending successfully"));
}
else {
if (!processEndingOutcome.IsSuccess()) {
const FGameLiftError& error = processEndingOutcome.GetError();
UE_LOG(GameServerLog, Error, TEXT("ProcessEnding() failed. Error: %s"),
error.m_errorMessage.IsEmpty() ? TEXT("Unknown error") : *error.m_errorMessage);
}
if (!destroyOutcome.IsSuccess()) {
const FGameLiftError& error = destroyOutcome.GetError();
UE_LOG(GameServerLog, Error, TEXT("Destroy() failed. Error: %s"),
error.m_errorMessage.IsEmpty() ? TEXT("Unknown error") : *error.m_errorMessage);
}
}
});
//This is the HealthCheck callback.
//Amazon GameLift Servers will invoke 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. Amazon GameLift Servers will default to 'false' if the game server doesn't respond in time.
//In this case, we're always healthy!
ProcessParameters->OnHealthCheck.BindLambda([]()
{
UE_LOG(GameServerLog, Log, TEXT("Performing Health Check"));
return true;
});
//GameServer.exe -port=7777 LOG=server.mylog
ProcessParameters->port = FURL::UrlConfig.DefaultPort;
TArray CommandLineTokens;
TArray CommandLineSwitches;
FCommandLine::Parse(FCommandLine::Get(), CommandLineTokens, CommandLineSwitches);
for (FString SwitchStr : CommandLineSwitches)
{
FString Key;
FString Value;
if (SwitchStr.Split("=", &Key, &Value))
{
if (Key.Equals("port"))
{
ProcessParameters->port = FCString::Atoi(*Value);
}
}
}
//Here, the game server tells Amazon GameLift Servers where to find game session log files.
//At the end of a game session, Amazon GameLift Servers uploads everything in the specified
//location and stores it in the cloud for access later.
TArray Logfiles;
Logfiles.Add(TEXT("GameLiftUnrealApp/Saved/Logs/server.log"));
ProcessParameters->logParameters = Logfiles;
//The game server calls ProcessReady() to tell Amazon GameLift Servers it's ready to host game sessions.
UE_LOG(GameServerLog, Log, TEXT("Calling Process Ready..."));
FGameLiftGenericOutcome ProcessReadyOutcome = GameLiftSdkModule->ProcessReady(*ProcessParameters);
if (ProcessReadyOutcome.IsSuccess())
{
UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_GREEN);
UE_LOG(GameServerLog, Log, TEXT("Process Ready!"));
UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_NONE);
}
else
{
UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_RED);
UE_LOG(GameServerLog, Log, TEXT("ERROR: Process Ready Failed!"));
FGameLiftError ProcessReadyError = ProcessReadyOutcome.GetError();
UE_LOG(GameServerLog, Log, TEXT("ERROR: %s"), *ProcessReadyError.m_errorMessage);
UE_LOG(GameServerLog, SetColor, TEXT("%s"), COLOR_NONE);
}
UE_LOG(GameServerLog, Log, TEXT("InitGameLift completed!"));
#endif
}
```
## 整合客户端游戏地图
启动游戏地图包含蓝图逻辑和用户界面元素，这些元素已经包含请求游戏会话和使用连接信息连接到游戏会话的基本代码。您可以按原样使用地图，也可以根据需要对其进行修改。将启动游戏地图与其他游戏资产一起使用，例如 Unreal Engine 提供的第三人称模板项目。这些资产可在内容浏览器中找到。您可以使用它们来测试插件的部署工作流程，或者作为为游戏创建自定义后端服务的指南。
该启动地图具有以下特性：
+ 它包括 Anywhere 实例集和托管 EC2 实例集的逻辑。在运行客户端时，您可以选择连接到任一实例集。
+ 客户端功能包括查找游戏会话（`SearchGameSessions()`）、创建新的游戏会话（`CreateGameSession()`）以及直接加入游戏会话。
+ 它会从项目的 Amazon Cognito 用户群体中获得一个唯一的玩家 ID（这是部署的 Anywhere 解决方案的一部分）。
**要使用启动游戏地图**
1. 在 UE 编辑器中，打开**项目设置、地图和模式**页面，然后展开**默认地图**部分。
1. 对于**编辑器启动地图**，从下拉列表中选择 StartupMap “”。您可能需要搜索位于 `... > Unreal Projects/[project-name]/Plugins/Amazon GameLift Servers Plugin Content/Maps` 中的文件。
1. 对于**游戏默认地图**，请从下拉列表中选择相同的 StartupMap “”。
1. 对于**服务器默认地图**，对于虚幻引擎 5.6 或更高版本，选择 “Lv1\$1ThirdPerson”，对于早期版本，选择 ThirdPersonMap “”。这是您的游戏项目中包含的默认地图。这张地图是为游戏中的两个玩家设计的。
1. 打开服务器默认地图的详细信息面板。将 “**GameMode 覆盖**” 设置为 “无”。
1. 展开**默认模式**部分，将**全局默认服务器游戏模式**设置为您为服务器集成而更新的游戏模式。
对项目进行这些更改后，就可以开始构建游戏组件了。
**注意**
对于虚幻引擎 5.6 或更高版本，如果在连接到游戏服务器后无法移动角色，请更新 BP\$1 ThirdPersonCharacter 蓝图以添加`IMC_Default`和的输入映射上下文，`IMC_MouseLook`如下所示：
![\[alt text not found\]](http://docs.aws.amazon.com/zh_cn/gameliftservers/latest/developerguide/images/unreal-enhanced-input-blueprint.png)
## 打包游戏组件
**打包游戏服务器和游戏客户端生成包**
1. 在 Unreal Engine 编辑器的源代码构建版本中打开游戏项目。
1. 如果使用虚幻引擎 5.6 或更高版本，请前往**编辑、项目设置、打包**。在**项目内容目录中找到 Cook 所有内容**并将其启用。
1. 使用编辑器打包游戏客户端和服务器生成包。
1. 选择一个目标。前往**平台、Windows**，然后选择以下选项之一：
+ 服务器：`[your-application-name]Server`
+ 客户：`[your-application-name]Client`
1. 启动构建。转到**平台、Windows、程序包项目**。
每个打包过程都会生成一个可执行文件：`[your-application-name]Client.exe` 或 `[your-application-name]Server.exe`。
在插件中，在本地工作站上设置客户端和服务器构建可执行文件的路径。
# 适用于 Unreal 的插件：使用 Amazon GameLift Servers Anywhere 在本地托管游戏
使用此工作流程将您的本地工作站设置为使用 Anywhere 实例集的游戏服务器主机。在部署到基于云的托管式实例集之前，您可以使用该流程来测试您的游戏服务器集成。它也可用于在迭代游戏开发期间进行本地测试。
**要启动 Amazon GameLift Servers Anywhere 工作流程，请执行以下操作：**
+ 在 Unreal 编辑器主工具栏中，选择 Amazon GameLift Servers 菜单，然后选择**通过 Anywhere 托管**。此操作将打开插件页面**部署 Anywhere**，其中提供了集成、构建和启动游戏组件的六步流程。
## 步骤 1：设置配置文件
选择您要在遵循此工作流程时使用的配置文件。您选择的配置文件会影响工作流程中的所有步骤。您创建的所有资源都与个人资料的 AWS 账户相关联，并放置在个人资料的默认 AWS 区域中。个人资料用户的权限决定了您对 AWS 资源和操作的访问权限。
**设置用户配置文件**
1. 从可用配置文件的下拉列表中选择一个配置文件。如果您还没有个人资料或想要创建新的个人资料，请前往 **Amazon GameLift** 菜单并选择 “**设置 AWS 用户资料**”。
1. 如果引导状态不是“活动”，请选择**引导配置文件**并等待状态变为“活动”。
## 步骤 2：设置游戏代码
在此步骤中，准备您的游戏服务器和游戏客户端生成包，使其能够与 Amazon GameLift Servers 搭配使用。如果您尚未集成游戏代码，请参阅[适用于 Unreal 的插件：集成游戏代码](unreal-plugin-integrate.md)。在本地工作站上输入游戏可执行文件的路径。
+ 游戏服务器：将您的游戏服务器与适用于 Amazon GameLift Servers 的服务器 SDK 集成，并打包您的游戏服务器生成包。有关说明，请参阅[适用于 Unreal 的插件：集成游戏代码](unreal-plugin-integrate.md)。游戏服务器必须与服务器 SDK 集成，才能与 Amazon GameLift Servers 服务建立通信，并响应启动新游戏会话和接受游戏客户端连接的提示。
+ 游戏客户端：您至少需要一个可以使用 IP 地址和端口信息连接到您的游戏服务器的游戏客户端。如果您尚未设置游戏客户端组件Amazon GameLift Servers，则可以使用该 AWS CLI 工具手动请求新的游戏会话、获取连接信息，然后使用该信息连接游戏客户端。
有时，您需要借助后端服务向 Amazon GameLift Servers 服务发送新游戏会话请求，并将连接信息回传给游戏客户端。您可以使用插件附带的测试地图，将客户端 Amazon GameLift Servers 功能添加到您的游戏项目中。有关构建自定义解决方案的帮助，请参阅[集成 Amazon GameLift Servers 游戏客户端功能](gamelift-sdk-client-api.md)。
## 步骤 3：连接到 Anywhere 实例集
在此步骤中，您将指定要使用的 Anywhere 实例集。Anywhere 实例集定义了一组计算资源，这些资源可以位于任何地方，用于托管游戏服务器。
+ 如果您当前使用的 AWS 账户已有 Anywhere 舰队，请打开舰队名称下拉字段并选择舰队。此下拉列表仅显示当前处于活动状态的用户配置文件 AWS 所在地区的 Anywhere 舰队。
+ 如果目前没有实例集，或者您想创建新实例集，请选择创建新的 Anywhere 实例集并提供实例集名称。
在您为项目选择 Anywhere 实例集后，Amazon GameLift Servers 会验证实例集状态是否处于活动状态并显示实例集 ID。您可以在 Unreal 编辑器的输出日志中跟踪此请求的进度。
## 步骤 4：注册工作站
在此步骤中，您将本地工作站注册为新的 Anywhere 实例集中的计算资源。
**将您的工作站注册为 Anywhere 计算**
1. 输入本地计算机的计算名称。如果您在实例集中添加多个计算，则名称必须是唯一的。
1. 为您的本地计算机提供 IP 地址。此字段默认为您计算机的公有 IP 地址。您也可以使用 localhost（127.0.0.1），前提是在同一台计算机上运行游戏客户端和服务器。
1. 选择注册计算。您可以在 Unreal 编辑器的输出日志中跟踪此请求的进度。
作为对这一操作的响应，Amazon GameLift Servers 会验证它是否可以连接到计算并返回有关新注册的计算的信息。它还会创建游戏可执行文件在初始化与 Amazon GameLift Servers 服务的通信时所需的控制台参数。
## 步骤 5：生成身份验证令牌
基于 Anywhere 计算运行的游戏服务器进程需要身份验证令牌才能调用 Amazon GameLift Servers 服务。每当从插件启动游戏服务器时，该插件都会自动生成并存储 Anywhere 实例集的身份验证令牌。身份验证令牌值存储为命令行参数，您的服务器代码可以在运行时检索该参数。
上面提供的代码示例还可让您使用[适用于 API 请求的AWS 签名版本 4（SigV4）](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html)。Sigv4 是用于向 API 请求添加身份验证信息的 AWS 签名协议。
您无需在此步骤中执行任何操作。
## 步骤 6：启动游戏
至此，您已经完成了使用 Amazon GameLift Servers 在本地工作站上启动和玩多人游戏所需的所有任务。
**玩托管游戏**
1. 启动游戏服务器。游戏服务器将在准备好托管游戏会话时通知 Amazon GameLift Servers。
1. 启动您的游戏客户端，然后使用新功能启动新的游戏会话。此请求通过新的后端服务发送到 Amazon GameLift Servers。作为回应，Amazon GameLift Servers 会调用在本地计算机上运行的游戏服务器以启动新的游戏会话。当游戏会话准备好接受玩家时，Amazon GameLift Servers 会提供连接信息，供游戏客户端加入游戏会话。
# 适用于 Unreal 的插件：将游戏部署到托管式 EC2 实例集
在此工作流程中，部署您的游戏，使其托管在 Amazon GameLift Servers 托管的基于云的计算资源上。将您的集成式游戏服务器生成包上传到 Amazon GameLift Servers 服务进行部署。如果您尚未集成游戏代码，请参阅[适用于 Unreal 的插件：集成游戏代码](unreal-plugin-integrate.md)。此工作流程完成后，您将拥有一个可以连接到云端游戏服务器且正常运行的游戏客户端。
**要启动 Amazon GameLift Servers 托管的 Amazon EC2 工作流程，请执行以下操作：**
+ 在 Unreal 编辑器主工具栏中，选择 Amazon GameLift Servers 菜单，然后选择**通过托管式 EC2 进行托管**。此操作将打开插件页面**部署 Amazon EC2 Fleet**，其中提供了集成、构建、部署和启动游戏组件的六步流程。
## 步骤 1：设置配置文件
选择您要在遵循此工作流程时使用的配置文件。您选择的配置文件会影响工作流程中的所有步骤。您创建的所有资源都与个人资料的 AWS 账户相关联，并放置在个人资料的默认 AWS 区域中。个人资料用户的权限决定了您对 AWS 资源和操作的访问权限。
**设置用户配置文件**
1. 从可用配置文件的下拉列表中选择一个配置文件。如果您还没有个人资料或想要创建新的个人资料，请前往 **Amazon GameLift** 菜单并选择 “**设置 AWS 用户资料**”。
1. 如果引导状态不是“活动”，请选择**引导配置文件**并等待状态变为“活动”。
## 步骤 2：设置游戏代码
在此步骤中，准备您的游戏服务器和游戏客户端生成包，使其能够与适用于 Unreal 的 Amazon GameLift Servers C\$1\$1 服务器 SDK 搭配使用。如果您尚未集成游戏代码并构建游戏客户端和服务器可执行文件，请参阅[适用于 Unreal 的插件：集成游戏代码](unreal-plugin-integrate.md)。在本地工作站上输入游戏可执行文件的路径。
在工作流程的这个步骤中，该插件会提供指向说明和源代码的链接，用于设置 Unreal 编辑器的源代码构建版本。在构建客户端和服务器组件时，需要使用源代码构建版本。
构建与服务器 SDK 集的游戏服务器后，请完成以下任务来做好准备，以便将其上传到 Amazon GameLift Servers 进行托管。
### 准备好服务器生成包以进行云部署（Windows）
在 Unreal 编辑器默认存储服务器生成包文件的 `WindowsServer` 文件夹中，添加以下内容：
1. **将服务器生成包安装脚本复制到 `WindowsServer` 文件夹的根目录中。**安装脚本包含在插件下载内容中。查找文件 `[project-name]/Plugins/Resources/CloudFormation/extra_server_resources/install.bat`。Amazon GameLift Servers 使用此文件在您的托管计算资源上安装服务器生成包。
1. **将 `VC_redist.x64.exe` 文件复制到 `WindowsServer` 文件夹的根目录中。**如果您使用的是 Unreal Engine 5.6 版或更高版本，可以跳过此步骤。此文件包含在您的 Visual Studio 安装中，通常位于 `C:/Program Files (x86)/Microsoft Visual Studio/2019/Professional/VC/Redist/MSVC/v142`。
1. **将 OpenSSL 库文件添加到游戏服务器生成包中。**如果您的游戏服务器与服务器 SDK 5.3 或更高版本集成，可以跳过此步骤。此版本包含在适用于 Unreal 的 Amazon GameLift Servers 插件 3.0 版或更高版本中。
手动找到 OpenSSL 库并将其复制到您的游戏生成包目录中，位置为 `/Binaries/Win64`。您**必须**使用与您的 Unreal Engine 5 版本相同的 OpenSSL 版本。使用错误的 OpenSSL 库部署的游戏生成包将无法与 Amazon GameLift Servers 服务通信。
在您的游戏引擎源代码中查找 OpenSSL 库。具体位置因开发环境而异：
在 Windows 上：
+ `[ENGINE_ROOT_DIR]\Engine\Extras\ThirdPartyNotUE\libimobiledevice\x64\libssl-1_1-x64.dll`
+ `[ENGINE_ROOT_DIR]\Engine\Extras\ThirdPartyNotUE\libimobiledevice\x64\libcrypto-1_1-x64.dll`
在 Linux 上：
+ `Engine/Source/Thirdparty/OpenSSL/1.1.1n/include/libssl.so.1.1`
+ `Engine/Source/Thirdparty/OpenSSL/1.1.1n/include/libcrypto.so.1.1`
### 准备好服务器生成包以进行云部署（Linux）
有关如何准备专为 Linux 构建的游戏服务器的更多详细说明，请参阅[在 Amazon Linux 上为适用于 Unreal Engine 5 的 Amazon GameLift Servers 构建服务器 SDK](https://github.com/aws/amazon-gamelift-toolkit/tree/main/building-gamelift-server-sdk-for-unreal-engine-and-amazon-linux)。
1. **指定一个工作目录来整理生成包文件。**工作目录的结构按原样部署到每个托管计算资源上。添加您的 Linux 构建的游戏服务器以及所有依赖文件。
1. **在工作目录的根目录中创建服务器生成包安装脚本。**如果需要，请创建一个 `install.sh` 文件，并添加正确安装游戏服务器生成包所需的所有命令。Amazon GameLift Servers 使用此文件将服务器生成包安装到每个 EC2 托管资源上。
1. **将 OpenSSL 库文件添加到游戏服务器生成包中。**如果您的游戏服务器与服务器 SDK 5.3 或更高版本集成，可以跳过此步骤。
手动查找并复制库。您**必须**使用与您的 Unreal Engine 5 版本相同的 OpenSSL 版本。使用错误的 OpenSSL 库部署的游戏生成包将无法与 Amazon GameLift Servers 服务通信。
1. 在您的游戏引擎源代码中查找 OpenSSL 库。具体位置因开发环境而异：
在 Windows 上：
+ `[ENGINE_ROOT_DIR]\Engine\Extras\ThirdPartyNotUE\libimobiledevice\x64\libssl-1_1-x64.dll`
+ `[ENGINE_ROOT_DIR]\Engine\Extras\ThirdPartyNotUE\libimobiledevice\x64\libcrypto-1_1-x64.dll`
在 Linux 上：
+ `Engine/Source/Thirdparty/OpenSSL/1.1.1n/include/libssl.so.1.1`
+ `Engine/Source/Thirdparty/OpenSSL/1.1.1n/include/libcrypto.so.1.1`
1. 找到 OpenSSL 库后，将其复制到您的游戏生成包目录中，位置为 `/Binaries/Linux`。
## 步骤 3：选择部署方案
在此步骤中，您可以选择此时要部署的游戏托管解决方案。使用任何方案，您都可以对游戏进行多个部署。
+ 单区域队列：将您的游戏服务器部署到活动配置文件默认 AWS 区域中的单个托管资源队列。此方案是测试服务器与 AWS 集成和服务器构建配置的良好起点。它部署了以下资源：
+ 已安装并运行游戏服务器构建的AWS 实例集（按需型）。
+ Amazon Cognito 用户群体和客户端，使玩家能够进行身份验证和开始游戏。
+ 与 APIs用户池关联的 API 网关授权器。
+ Web ACl 用于限制玩家对 API 网关的过多调用。
+ API 网关 \$1 Lambda 函数，供玩家申请游戏位置。如果两者都不可用，则此函数调用 `CreateGameSession()`。
+ API 网关 \$1 Lambda 函数，供玩家获取游戏请求的连接信息。
+ FlexMatch 舰队：将你的游戏服务器部署到一组舰队中，并设置一个带有规则的 FlexMatch 匹配器来创建玩家对战。此方案使用低成本的竞价型托管和一个多实例集、多位置结构，以实现持久可用性。当您准备好开始为托管解决方案设计对战构建器组件时，此方法非常有用。在这种方案下，您将为此解决方案创建基本资源，并可以根据需要后续对其进行自定义。它部署了以下资源：
+ FlexMatch 配对配置和配对规则设置为接受玩家请求和表单匹配。
+ 三个 AWS 实例集，安装了游戏服务器构建，并在多个位置运行。包括两个竞价型实例集和一个按需型实例集作为备份。
+ AWS 游戏会话放置队列，通过寻找尽可能好的托管资源（基于可行性、成本、玩家延迟等）并启动游戏会话来满足对提议对战的请求。
+ Amazon Cognito 用户群体和客户端，使玩家能够进行身份验证和开始游戏。
+ 与 APIs用户池关联的 API 网关授权器。
+ Web ACl 用于限制玩家对 API 网关的过多调用。
+ API 网关 \$1 Lambda 函数，供玩家申请游戏位置。此函数调用 `StartMatchmaking()`。
+ API 网关 \$1 Lambda 函数，供玩家获取游戏请求的连接信息。
+ Amazon DynamoDB 表，用于存储玩家的对战票证和游戏会话信息。
+ SNS 主题 \$1 用于处理事件的 Lambda 函数。 GameSessionQueue
## 步骤 4：设置游戏参数
在此步骤中，您将描述要上传到的游戏 AWS；
+ 服务器生成包名称：为游戏服务器生成包提供一个有意义的名称。 AWS 使用此名称来指代上传并用于部署的服务器生成包的副本。
+ 服务器构建操作系统：输入构建服务器以在其中运行的操作系统。这将告诉 AWS 使用哪种类型的计算资源来托管您的游戏。
+ 游戏服务器文件夹：确定本地服务器构建文件夹的路径。
+ 游戏服务器构建：确定游戏服务器可执行文件的路径。
+ 游戏客户端路径：确定游戏客户端可执行文件的路径。
+ 客户端配置输出：此字段需要指向您的客户端版本中包含您的 AWS 配置的文件夹。在以下位置寻找：`[client-build]/[project-name]/Content/CloudFormation`。
## 步骤 5：部署方案
在此步骤中，您将根据所选的部署方案将游戏部署到云托管解决方案。在 AWS 验证服务器生成包、预置托管资源、安装游戏服务器、启动服务器进程以及让它们做好托管游戏会话的准备时，此过程可能需要数分钟。
要开始部署，请选择**部署 CloudFormation**。您可以在此处跟踪您的游戏托管状态。要了解更多详细信息，您可以登录 AWS 管理控制台查看 AWS 和查看事件通知。请务必使用与插件中活跃用户个人资料相同的账户、用户和 AWS 地区登录。
部署完成后，您的游戏服务器将安装在 AWS EC2 实例上。至少有一个服务器进程正在运行并准备开始游戏会话。
## 步骤 6：启动客户端
至此，您已经完成了启动和玩使用 Amazon GameLift Servers 托管的多人游戏所需的所有任务。要玩游戏，请启动您的游戏客户端实例。
如果您部署了单个实例集方案，则可以用一个玩家打开一个客户端实例，进入服务器地图并四处移动。打开游戏客户端的其他实例，将第二个玩家添加到同一个服务器游戏地图中。
如果您部署了 FlexMatch 场景，则解决方案会等待至少两个客户端排队等候游戏会话放置，然后玩家才能进入服务器地图。
# 适用于 Unreal 的插件：将游戏部署到托管式容器实例集
使用此引导式插件工作流程为您的游戏服务器创建容器映像，并将其部署到基于容器的托管解决方案。如果您尚未集成游戏代码，请参阅[适用于 Unreal 的插件：集成游戏代码](unreal-plugin-integrate.md)。成功完成此工作流程后，您的容器化游戏服务器将在云中运行，您可以使用该插件启动游戏客户端、连接到游戏会话和玩游戏。
## 开始之前
此工作流程假定您已完成以下任务。
+ **将游戏服务器代码与 Amazon GameLift Servers 服务器 SDK 集成。**您的托管游戏服务器必须能够与 Amazon GameLift Servers 服务通信，以便能够响应启动新游戏会话和报告游戏会话状态的请求。如果您尚未完成此任务，建议您先按照“通过 Anywhere 托管”插件工作流程进行操作。有关准备游戏服务器代码的指导，请参阅[更新游戏服务器代码](unreal-plugin-integrate.md#unreal-plugin-anywhere-integrate-simple-server)。对于托管式容器实例集，必须将游戏与服务器 SDK 5.2 版或更高版本集成。
**注意**
如果您使用的是启动游戏地图，则此任务已经为您完成了。
+ **将游戏服务器可执行文件打包，以便在 Linux 上运行。**如果您在 Windows 上开发，并且集成了 C\$1\$1 服务器 SDK 5.2.x 版或更早版本，则需要使用 [Unreal 交叉编译工具包](http://cross-compile toolkit for your UE version)。或者，您可以设置一个单独的 Linux 工作区，或使用适用于 Linux 的 Windows 子系统（WSL）之类的工具。
+ **收集要与游戏服务器生成包一起部署的文件。**在本地计算机上，创建一个工作目录来整理将内置到游戏服务器容器映像中的文件。这些文件可能包括游戏依赖项、启动游戏服务器的脚本以及启动容器时的其他进程等。
+ **为游戏服务器生成包添加 OpenSSL 库文件。**如果您的游戏服务器与服务器 SDK 5.3 或更高版本集成，可以跳过此步骤。
手动找到 OpenSSL 库并将其复制到您的游戏生成包目录中，位置为 `/Binaries/Win64`。您**必须**使用与您的 Unreal Engine 5 版本相同的 OpenSSL 版本。使用错误的 OpenSSL 库部署的游戏生成包将无法与 Amazon GameLift Servers 服务通信。
要找到 OpenSSL 库，请查找您的游戏引擎源代码。具体位置因开发环境而异：
在 Windows 上：
+ `[ENGINE_ROOT_DIR]\Engine\Extras\ThirdPartyNotUE\libimobiledevice\x64\libssl-1_1-x64.dll`
+ `[ENGINE_ROOT_DIR]\Engine\Extras\ThirdPartyNotUE\libimobiledevice\x64\libcrypto-1_1-x64.dll`
在 Linux 上：
+ `Engine/Source/Thirdparty/OpenSSL/1.1.1n/include/libssl.so.1.1`
+ `Engine/Source/Thirdparty/OpenSSL/1.1.1n/include/libcrypto.so.1.1`
+ **将游戏客户端代码与 Amazon GameLift Servers 集成。**要完成此任务，其中一种方法是添加已集成的示例资产（包含在插件中）。有关准备游戏客户端代码的指导，请参阅[整合客户端游戏地图](unreal-plugin-integrate.md#unreal-plugin-anywhere-integrate-simple-client)。
+ **在本地计算机上安装 Docker。**如果您希望插件为您创建容器映像并将其推送到 ECR 存储库，则需要安装此工具。或者，您可以手动执行这些任务，并指示插件使用现有的容器映像。有关手动构建映像的更多信息，请参阅[为 Amazon GameLift Servers 构建容器映像](https://docs.aws.amazon.com/gameliftservers/latest/developerguide/containers-prepare-images.html)。
**要启动 Amazon GameLift Servers 托管式容器工作流程，请执行以下操作：**
+ 在 Unreal 编辑器主工具栏中，选择 Amazon GameLift Servers 菜单，然后选择**托管式容器**。此操作将打开插件页面 “**使用托管容器托管**”，该页面显示了使用游戏服务器版本创建容器镜像、将其部署到容器队列以及启动游戏的 step-by-step过程。
## 第 0 步：设置您的个人资料
此部分显示您当前选择的用户配置文件。请确认当前的用户配置文件就是您希望在此工作流程中使用的配置文件。您在此工作流程中创建的所有资源都与个人资料的 AWS 帐户相关联，并放置在配置文件的默认 AWS 区域中。个人资料用户的权限决定了您对 AWS 资源和操作的访问权限。
在以下情况下，您可能需要修改所选的用户配置文件：
+ 当前未选择任何配置文件。
+ 您想要选择其他配置文件或创建新的配置文件。
+ 您需要引导所选的配置文件（如果引导状态为非活动）。
**设置或更改所选用户配置文件**
+ 在Amazon GameLift Servers菜单中，选择**开放 AWS 访问凭证**。
## 第 1 步：评测容器就绪情况
在将游戏服务器部署到容器实例集之前，必须将其打包成容器映像并存储在 Amazon ECR 存储库中。该插件可以为您完成这些任务，或者您也可以手动完成这些任务。在此步骤中，提供有关您的容器映像和 ECR 存储库状态的信息。
使用评测问题告知插件，它需要采取哪些步骤：
+ **创建新的容器映像。**如果您选择此选项，下一步将提示您输入游戏服务器生成包目录和生成包可执行文件的位置。该插件使用 Dockerfile 模板（由 Amazon GameLift Servers 提供），并自动为您的游戏配置该模板。您可以参阅[为 Amazon GameLift Servers 构建容器映像](containers-prepare-images.md)，以查看该模板。选择此选项后，请指明您希望插件存储新映像的位置：
+ 创建一个新的 Amazon ECR 存储库，并将容器映像推送到该存储库。该插件使用您选择的用户个人资料 AWS 区域 中的 AWS 帐户和默认帐户创建私有 ECR 存储库。
+ 将容器映像推送到之前创建的 Amazon ECR 存储库。如果您选择此选项，下一步将提示您从列表中选择现有的 Amazon ECR 存储库。该列表包括该 AWS 账户的所有 Amazon ECR 存储库，并且默认出现在您选择的用户个人资料 AWS 区域 中。您可以选择公有存储库或私有存储库。
+ **使用现有的容器映像。**如果您手动构建了映像，我们建议您使用 Amazon GameLift Servers 提供的 Dockerfile 模板，该模板可在[为 Amazon GameLift Servers 构建容器映像](containers-prepare-images.md)中获取。选择此选项后，请指明映像的位置。
+ 本地存储的 Docker 生成的映像。如果您选择此选项，该插件会创建一个新的 Amazon ECR 私有存储库，并将本地映像文件推送到该存储库。下一步将提示您输入映像 ID，插件会使用该 ID 来找到映像文件。
+ 已存储在 Amazon ECR 存储库中的容器映像。如果您选择此选项，下一步将提示您从列表中选择现有的 Amazon ECR 存储库和映像。该列表包括该 AWS 账户的所有 Amazon ECR 存储库，并且默认出现在您选择的用户个人资料 AWS 区域 中。您可以选择公有存储库或私有存储库。
## 第 2 步：配置映像部署
在此步骤中，提供插件将您的容器映像部署到容器实例集所需的信息。此步骤要求提供以下信息：
+ 您的游戏服务器生成包、容器映像或 Amazon ECR 存储库的位置，具体取决于您在第 1 步中的选择。
+ 用于托管式容器部署的方案。
+ 客户端配置输出路径。在您的客户端版本中选择包含您的 AWS 配置的文件夹。在以下位置寻找：`[client-build]/[project-name]/Content/CloudFormation`。
+ 可选部署设置。此部分包含插件默认使用的配置设置。您可以修改这些设置，也可以保留默认值
+ 默认情况下，游戏名称设置为游戏项目的名称。插件创建的所有 AWS 资源都引用游戏名称值。
+ 端口范围、内存限制和 vCPU 限制是容器实例集的配置设置。有关自定义这些值的更多信息，请参阅[配置网络连接](containers-design-fleet.md#containers-custom-network)以了解连接端口范围，并参阅[设置资源限制](containers-design-fleet.md#containers-design-fleet-limits)以了解资源限制。
+ 容器映像标签用于在 Amazon ECR 中对容器映像进行分类。默认值为 `unreal-gamelift-plugin`。
+ Amazon ECR 存储库的名称。只有在插件为您创建 ECR 存储库时，您才能编辑此字段以建议自定义名称。默认值为 `unreal-game lift-plugin-ecr-repository`。
### 部署方案选项
#### 单区域容器实例集
此方案将您的游戏服务器部署到单个容器实例集。它是测试服务器与 AWS 集成和容器配置的良好起点。它部署了以下资源：
+ Amazon GameLift Servers 容器组定义，描述了如何在容器实例集上部署和运行您的容器映像。
+ 已安装并运行您的游戏服务器容器的 Amazon GameLift Servers 容器实例集（按需型），附带别名。
+ Amazon Cognito 用户群体和客户端，使玩家能够进行身份验证和开始游戏。
+ 将用户池与 APIs关联的 API Gateway 授权方。
+ Web 访问控制列表（ACL），用于限制玩家对 API 网关的过多调用。
+ 代表游戏客户端向 Amazon GameLift Servers 服务发出请求的后端服务，例如请求游戏会话和加入游戏：
+ API 网关 \$1 Lambda 函数，供玩家申请游戏会话位置。如果没有可用的空闲位置，则此函数调用 `CreateGameSession()`。
+ API 网关 \$1 Lambda 函数，供玩家获取游戏请求的连接信息。
#### 包含 FlexMatch 的单区域容器实例集
此方案将您的游戏服务器部署到容器实例集、配置游戏会话放置并设置 FlexMatch 对战。当您准备开始为托管解决方案设计自定义配对器时，此方案非常有用。使用此方案时，您将为该解决方案创建基本资源，并可以根据需要后续对其进行自定义。它部署了以下资源：
+ Amazon GameLift Servers 容器组定义，描述了如何在容器实例集上部署和运行您的容器映像。
+ 已安装并运行您的游戏服务器容器的 Amazon GameLift Servers 容器实例集（按需型），附带别名。
+ FlexMatch 对战配置和对战规则设置为接受玩家请求和组成对战。
+ Amazon GameLift Servers 游戏会话队列，通过寻找尽可能好的托管资源（基于可行性、成本、玩家延迟等）并启动游戏会话来满足对提议对战的请求。
+ Amazon Cognito 用户群体和客户端，使玩家能够进行身份验证和开始游戏。
+ 将用户池与 APIs关联的 API Gateway 授权方。
+ Web 访问控制列表（ACL），用于限制玩家对 API 网关的过多调用。
+ 代表游戏客户端向 Amazon GameLift Servers 服务发出请求的后端服务，例如请求游戏会话和加入游戏：
+ API 网关 \$1 Lambda 函数，供玩家申请游戏会话位置。如果没有可用的空闲位置，则此函数调用 `StartMatchmaking()`。
+ API 网关 \$1 Lambda 函数，供玩家获取游戏请求的连接信息。
+ DynamoDB 表，用于存储玩家的对战票证和游戏会话信息。
+ 亚马逊 SNS 主题 \$1 用于处理事件的 Lambda 函数。 GameSessionQueue
## 部署容器实例集
实例集配置完成后，选择**部署容器实例集**按钮以开始部署。插件将创建容器映像并将其推送到 ECR，为容器实例集预调配托管资源，并为所选托管解决方案场景部署实例集和其他 AWS 资源，整个过程可能需要几分钟。
开始部署时，您可以跟踪每个步骤的进度。根据您的配置，步骤可能包括以下内容：
+ 配置容器映像
+ 创建新的 Amazon ECR 存储库
+ 构建映像并推送到 Amazon ECR
+ 创建容器组定义
+ 创建容器实例集
有关更详细的部署信息，请选择**在 AWS 管理控制台中查看**。当容器实例集达到活动状态时，即表示实例集正在主动运行容器，其中的服务器进程已准备好托管游戏会话。
部署完成后，您将拥有一个正常运行的容器实例集，随时可以托管游戏会话并接受玩家连接。
您无法停止正在进行的部署。如果部署进入不良状态或失败，您可以使用**重置部署**选项重新开始。
## 启动客户端
至此，您已经完成了启动和玩使用 Amazon GameLift Servers 托管的多人游戏所需的所有任务。要玩游戏，请选择**启动客户端**以启动游戏客户端的本地实例。
+ 如果您部署了单个实例集方案，请打开一个包含一名玩家的游戏客户端实例，然后进入服务器地图并进行移动操作。您可以打开游戏客户端的第二个实例，将第二名玩家添加到同一个服务器游戏地图中。
+ 如果您部署了 FlexMatch 方案，则托管解决方案会等待至少两个游戏客户端发出对战请求。打开至少两个游戏客户端实例，每个实例各包含一名玩家。这两名玩家将进行匹配，并收到加入游戏会话以进行对战的提示。
## 更新容器实例集
如果您已成功部署托管式容器托管解决方案，可以使用**更新部署**功能。此选项可让您更新已部署容器实例集的配置设置，而无需创建新的实例集。
更新部署时，您可以部署包含不同游戏服务器生成包的容器映像，更改 Amazon ECR 存储库，选择不同的部署方案，以及自定义可选配置设置。
如果您已准备好部署更改，请选择“更新”。部署更新所需的时间与全面部署所需的时间类似。要了解详细的部署信息，请选择**在 AWS 管理控制台中查看**。
## 清理已部署的资源
作为最佳实践，请在不再需要托管容器解决方案时立即清理这些 AWS 资源。如果不删除这些资源，它们可能会继续产生费用。
请删除以下资源：
+ 托管式容器资源堆栈。此堆栈中的资源取决于您选择的部署方案。要删除整个堆栈，请使用 CloudFormation 控制台。从 Amazon GameLift Servers 插件生成的堆栈使用以下命名规范：`GameLiftPluginForUnreal-{GameName}-Containers`。在插件中启动新的托管式容器部署之前，请等待堆栈删除过程完成。有关更多信息，请参阅[从 CloudFormation 控制台删除堆栈](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-delete-stack.html)。
+ Amazon ECR 存储库。如果您使用插件为容器映像创建了存储库，可能需要删除所有不再需要的存储库。在重置托管式容器部署之前，无需删除存储库。如果您更新或重置部署，除非指示使用其他存储库，否则插件将自动使用同一个存储库。有关更多信息，请参阅[在 Amazon ECR 中删除私有存储库](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-delete.html)。
# Amazon GameLift Servers适用于 Unity 的插件（服务器 SDK 5.x）
此插件将 Amazon GameLift Servers C\$1 服务器 SDK 和工具添加到 Unity 编辑器中。使用引导式 UI 工作流程将服务器 SDK 功能集成到您的游戏项目中，并为您的游戏服务器部署 Amazon GameLift Servers 托管解决方案。
利用插件，您可以构建一个基本的托管解决方案，然后根据需要进行优化和自定义。设置以本地工作站为主机的 Amazon GameLift Servers Anywhere 实例集。对于使用托管式 EC2 或托管式容器实例集的云托管，请使用完整的解决方案部署游戏服务器，以便管理游戏会话请求和客户端连接。
**Topics**
+ [为 Unity 游戏项目安装插件](#unity-plugin-install)
+ [Unity 插件：设置 AWS 用户个人资料](unity-plug-in-profiles.md)
+ [适用于 Unity 的插件：使用 Amazon GameLift Servers Anywhere 设置本地测试](unity-plug-in-anywhere.md)
+ [适用于 Unity 的插件：将游戏部署到托管式 EC2 实例集](unity-plug-in-ec2.md)
+ [适用于 Unity 的插件：将游戏部署到托管式容器实例集](unity-plug-in-container.md)
## 为 Unity 游戏项目安装插件
**[从以下地址获取 Unity Amazon GameLift Servers 插件 GitHub](https://github.com/amazon-gamelift/amazon-gamelift-plugin-unity)**
有关如何为游戏项目安装插件的信息，请参阅 GitHub 存储库自述文件。
该插件包括以下组件：
+ Unity 编辑器的插件模块。安装插件后，新的主菜单项可让您访问 Amazon GameLift Servers 的功能。
+ 适用于具有客户端功能的 Amazon GameLift Servers 服务 API 的 C\$1 库。
+ 适用于 Amazon GameLift Servers 服务器 SDK（版本 5.x）的 C\$1 库。
+ 示例游戏内容（包括资产和场景），因此即使您没有生成包就绪的多人游戏，也可以试试 Amazon GameLift Servers。
+ 解决方案配置，作为 CloudFormation 模板提供，供插件在将游戏服务器部署到云端进行托管时使用。
此插件使用 AWS CloudFormation 模板为常见游戏场景部署托管解决方案。您可以使用提供的这些解决方案，也可以根据游戏需要对其进行自定义。
# Unity 插件：设置 AWS 用户个人资料
安装插件后，使用有效的 AWS 帐户设置用户个人资料。您可以在插件中维护多个配置文件，但一次只能选择一个配置文件。每当使用插件时，请选择要使用的配置文件。每个工作流程页面都会显示当前选择的配置文件。
维护多个配置文件使您能够在不同的托管部署之间切换。例如，您可以设置使用相同 AWS 账户但部署到不同 AWS 区域的配置文件。或者，您可以使用不同的 AWS 帐户、用户和权限集来设置配置文件。
**注意**
如果您已在工作站上安装了 AWS CLI 并且已经配置了配置文件，则该Amazon GameLift Servers插件将对其进行检测并将其列为现有配置文件。该插件会自动选择任何名为 `[default]` 的配置文件。您可以使用现有配置文件或创建新的配置文件。
必须启动所有配置文件才能在您的账户用户下设置一些必需的 AWS 资源。
**管理您的 AWS 个人资料**
1. 在 Unity 主工具栏中，选择 Amazon GameLift Servers 菜单，然后选择 **AWS 访问凭证**。此操作会打开 Amazon GameLift Servers 插件并转到**设置您的用户配置文件**页面。
1. 使用按钮创建新 AWS 帐户或为已有的 AWS 帐户设置用户个人资料。
1. 如果您还没有用户配置文件，系统会提示您输入配置文件详细信息并创建新的配置文件。提供以下信息：
+ 一个 AWS 账户。如果您创建了一个新 AWS 帐户，请使用链接 AWS 管理控制台 并按照提示进行操作。有关更多详细信息，请参阅[创建 AWS 账户](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-creating.html)。
+ 有权使用Amazon GameLift Servers和其他必需 AWS 服务的 AWS 用户。有关设置具有Amazon GameLift Servers权限的 AWS Identity and Access Management (IAM) 用户以及使用长期证书进行编程访问的说明，请参阅[设置 AWS 用户账户](setting-up-aws-login.md)。
+ 您的 AWS 用户的凭证。这些证书由 AWS 访问密钥 ID 和 AWS 密钥组成。有关更多详细信息，请参阅[获取访问密钥](https://docs.aws.amazon.com/cli/latest/userguide/cli-authentication-user.html#cli-authentication-user-get)。
+ AWS 区域。这是您要创建托管 AWS 资源的地理位置。在开发过程中，我们建议使用靠近您的实际位置的区域。从[支持的区域列表中选择一个 AWS 区域](https://docs.aws.amazon.com/general/latest/gr/gamelift.html)。
1. 如果插件检测到现有配置文件，则会显示可用配置文件列表。从列表中选择现有配置文件，或选择**添加其他配置文件**以创建新的配置文件。
## 引导用户配置文件
所有配置文件必须进行引导才能与 Amazon GameLift Servers 插件搭配使用。引导会创建特定于该配置文件的 Amazon S3 存储桶。它用于存储项目配置、构建构件和其他依赖项。存储桶不会在其他配置文件之间共享。
Bootstrapp涉及创建新 AWS 资源，并且可能会产生成本。
**要引导您的配置文件，请执行以下操作：**
1. 在 **AWS 访问凭证**页面上，检查要使用的用户配置文件的引导状态。如果配置文件的引导状态为“非活动”，并且未列出 S3 存储桶，则需要引导配置文件。
1. 选择要使用的配置文件，然后选择**引导配置文件**。
1. 等待引导状态变为“活动”。这可能需要几分钟的时间。
# 适用于 Unity 的插件：使用 Amazon GameLift Servers Anywhere 设置本地测试
在此工作流程中，您可以为 Amazon GameLift Servers 功能添加客户端和服务器游戏代码，然后使用该插件将您的本地工作站指定为测试游戏服务器主机。完成集成任务后，使用该插件来构建您的游戏客户端和服务器组件。
**要启动 Amazon GameLift Servers Anywhere 工作流程，请执行以下操作：**
+ 在 Unity 编辑器主菜单中，选择 **Amazon GameLift Servers**，然后选择**通过 Anywhere 托管**。此操作将打开插件页面，用于使用 @Anywhere 实例集设置您的游戏。该页面提供了集成、构建和启动游戏组件的五步流程。
## 设置配置文件
选择您在遵循此工作流程时要使用的配置文件。您选择的配置文件会影响工作流程中的所有步骤。您创建的所有资源都与个人资料的 AWS 账户相关联，并放置在个人资料的默认 AWS 区域中。个人资料用户的权限决定了您对 AWS 资源和操作的访问权限。
1. 从可用配置文件的下拉列表中选择一个配置文件。如果您还没有个人资料或想要创建新的个人资料，请前往**Amazon GameLift Servers**菜单并选择 “**设置 AWS 账户资料**”。
1. 如果引导状态不是“活动”，请选择**引导配置文件**并等待状态变为“活动”。
## 将游戏代码与 C\$1 服务器 SDK 集成。
**注意**
如果您导入了示例游戏，则可以跳过这一步。示例游戏资产已准备好所需的服务器和客户端代码。
在工作流程的这一步中，您需要更新游戏项目中的客户端和服务器代码。
+ 游戏服务器必须能够与 Amazon GameLift Servers 服务通信才能接收启动游戏会话的提示、提供游戏会话连接信息和报告状态。
+ 游戏客户端必须能够获取有关游戏会话的信息、加入或启动游戏会话以及获取连接信息才能加入游戏。
### 集成服务器代码
如果将您自己的游戏项目与自定义场景一起使用，请使用提供的示例代码将所需的服务器代码添加到您的游戏项目：
1. 在您的游戏项目文件中，打开 `Assets/Scripts/Server` 文件夹。如果该文件夹不存在，请创建它。
1. 前往 [aws/ GitHub ](https://github.com/aws/amazon-gamelift-plugin-unity) 仓库amazon-gamelift-plugin-unity并打开路径。`Samples~/SampleGame/Assets/Scripts/Server`
1. 找到文件 `GameLiftServer.cs` 并将其复制到游戏项目的 `Server` 文件夹中。构建服务器可执行文件时，请使用此文件作为构建目标。
示例代码包含以下所需的最少元素，这些元素使用了 Amazon GameLift Servers C\$1 服务器 SDK（版本 5）：
+ 初始化 Amazon GameLift Servers API 客户端。Amazon GameLift Servers Anywhere 实例集需要使用服务器参数进行 `InitSDK()` 调用。这些设置会自动设置，以便在插件中使用。
+ 实施所需的回调函数以响应来自 Amazon GameLift Servers 服务的请求，包括 `OnStartGameSession`、`OnProcessTerminate`、和 `onHealthCheck`。
+ 当服务器进程准备好托管游戏会话时，请使用指定端口调用 `ProcessReady()` 以通知 Amazon GameLift Servers 服务。
如果要自定义示例服务器代码，请参阅以下资源：
+ [借助服务器 SDK 将 Amazon GameLift Servers 添加到游戏服务器](gamelift-sdk-server-api.md)
+ [适用于 Amazon GameLift Servers 的 C\$1 服务器 SDK 5.x – 操作](integration-server-sdk5-csharp-actions.md)
### 集成客户端代码
如果将您自己的游戏项目与自定义场景一起使用，则需要将基本功能集成到游戏客户端。您还需要添加 UI 元素，让玩家可以登录并加入游戏会话。使用Amazon GameLift Servers（在 AWS SDK 中）的服务 API 来获取游戏会话信息、创建新的游戏会话或加入现有游戏会话，
使用 Anywhere 实例集构建要进行本地测试的客户端时，您可以添加对 Amazon GameLift Servers 服务的直接调用。当您开发要进行云托管的游戏时（或者您计划使用 Anywhere 实例集进行生产托管），您需要创建一个客户端后端服务来处理游戏客户端和 Amazon GameLift Servers 服务之间的所有通信。
要将 Amazon GameLift Servers 集成到客户端代码，请使用以下资源作为指南。
+ 将客户端与 GitHub repo 中的 GameLiftCoreApi 类集成 aw amazon-gamelift-plugin-unity s/。该类提供了用于玩家身份验证和检索游戏会话信息的控件。
+ 查看示例游戏集成，可在 GitHub 存储库 aw amazon-gamelift-plugin-unity s/ 中找到。`Samples~/SampleGame/Assets/Scripts/Client/GameLiftClient.cs`
+ 按照“将 Amazon GameLift Servers 添加到您的 Unity 游戏客户端”中的说明进行操作。
对于连接到 Anywhere 实例集的游戏客户端，您的游戏客户端需要以下信息。插件会自动更新您的游戏项目，以使用您在插件中创建的资源。
+ FleetId -您的 Anywhere 车队的唯一标识符。
+ FleetLocation -您的 Anywhere 舰队的自定义位置。
+ AwsRegion -托管您的 Anywhere 舰队的 AWS 区域。这是您在用户配置文件中设置的区域。
+ ProfileName -本地计算机上的 AWS 凭据配置文件，允许访问的 AWS SDK Amazon GameLift Servers。游戏客户端使用这些凭证来验证对 Amazon GameLift Servers 服务的请求的身份。
**注意**
凭证配置文件由插件生成并存储在本地计算机上。因此，您必须在本地计算机（或具有相同配置文件的计算机上）上运行客户端。
## 连接到 Anywhere 实例集
在此步骤中，您将指定要使用的 Anywhere 实例集。Anywhere 实例集定义了一组计算资源，这些资源可以位于任何地方，用于托管游戏服务器。
+ 如果您当前使用的 AWS 账户已有 Anywhere 舰队，请打开**舰队名称**下拉字段并选择舰队。此下拉列表仅显示当前活跃用户配置文件 AWS 所在地区的 Anywhere 舰队。
+ 如果目前没有实例集，或者您想创建新实例集，请选择**创建新的 Anywhere 实例集**并提供实例集名称。
在您为项目选择 Anywhere 实例集后，Amazon GameLift Servers 会验证实例集状态是否处于活动状态并显示实例集 ID。您可以在 Unity 编辑器的输出日志中跟踪此请求的进度。
## 注册计算
在此步骤中，您将本地工作站注册为新的 Anywhere 实例集中的计算资源。
1. 输入本地计算机的计算名称。如果您在实例集中添加多个计算，则名称必须是唯一的。
1. 选择**注册计算**。您可以在 Unity 编辑器的输出日志中跟踪此请求的进度。
插件会注册您的本地工作站，并将 IP 地址设置为 localhost（127.0.0.1）。此设置假定您将在同一台计算机上运行游戏客户端和服务器。
作为对这一操作的响应，Amazon GameLift Servers 会验证它是否可以连接到计算并返回有关新注册的计算的信息。
## 启动游戏
在此步骤中，您将构建游戏组件并启动它们来玩游戏。完成以下任务：
1. 配置游戏客户端。在此步骤中，您将提示插件更新游戏项目的 `GameLiftClientSettings` 资产。插件将使用该资产来存储游戏客户端连接到 Amazon GameLift Servers 服务所需的某些信息。
1. 如果您没有导入和初始化示例游戏，请创建一个新的 `GameLiftClientSettings` 资产。在 Unity 编辑器主菜单中，选择**资产、创建、Amazon GameLift、客户端设置**。如果您在项目中创建了多个 `GameLiftClientSettings` 副本，插件会自动检测到这一点，并通知您插件将更新哪个资产。
1. 在**启动游戏**中，选择**配置客户端：应用 Anywhere 设置**。此操作将更新游戏客户端设置，以使用您刚刚设置的 Anywhere 实例集。
1. 构建并运行游戏客户端。
1. 使用标准 Unity 构建流程构建客户端可执行文件。在**文件、构建设置**中，将平台切换为 **Windows、Mac 或 Linux**。如果您导入了示例游戏并初始化了设置，则构建列表和构建目标会自动更新。
1. 启动新构建的游戏客户端可执行文件的一个或多个实例。
1. 在 Anywhere 实例集中启动游戏服务器。选择**服务器：在编辑器中启动服务器**。此任务将启动一个实时服务器，只要 Unity 编辑器保持打开状态，您的客户端就可以连接到该服务器。
1. 启动或加入游戏会话。在您的游戏客户端实例中，使用 UI 将每个客户端加入游戏会话。如何执行此操作取决于您是如何向客户端添加功能的。
如果您使用的是示例游戏客户端，那么它具有以下特征：
+ 一个玩家登录组件。连接到 Anywhere 实例集上的游戏服务器时，不会进行玩家验证。您可以输入任意值来加入游戏会话。
+ 一个简单的加入游戏 UI。当一个客户端尝试加入游戏时，该客户端会自动查找有可用玩家位置的活动游戏会话。如果没有可用的游戏会话，该客户端会请求新的游戏会话。如果有可用的游戏会话，该客户端会请求加入该游戏会话。使用多个并发客户端来测试游戏时，第一个客户端会启动游戏会话，其余客户端会自动加入现有的游戏会话。
+ 有四个玩家位置的游戏会话。您最多可以同时启动四个游戏客户端实例，它们将加入同一游戏会话。
**通过服务器可执行文件启动（可选）**
您可以构建并启动游戏服务器可执行文件，以便在 Anywhere 实例集上进行测试。
1. 使用标准 Unity 构建流程构建服务器可执行文件。在**文件、构建设置**中，将平台切换为**专用服务器**，然后构建。
1. 使用您的 Anywhere 舰队 ID 和 AWS 区域调用 AWS CLI 命令 [get-compute-auth-token](https://docs.aws.amazon.com/cli/latest/reference/gamelift/get-compute-auth-token.html)，获取短期身份验证令牌。当您创建实例集时，实例集 ID 将显示在**连接到 Anywhere 实例集**中。当您选择有效的**个人资料时，该 AWS 地区将显示在 “设置您的**个人资料” 中。
```
aws gamelift get-compute-auth-token --fleet-id [your anywhere fleet ID] --region [your AWS region]
```
1. 通过命令行启动新构建的游戏服务器可执行文件，并传入有效的身份验证令牌。
```
my_project.exe --authToken [token]
```
# 适用于 Unity 的插件：将游戏部署到托管式 EC2 实例集
在此工作流程中，您将使用插件准备游戏，使其托管在由 Amazon GameLift Servers 管理的基于云的计算资源上。您需要为 Amazon GameLift Servers 功能添加客户端和服务器游戏代码，然后将服务器生成包上传到 Amazon GameLift Servers 服务进行托管。此工作流程完成后，您将拥有在云中运行的游戏服务器，以及可以连接到该服务器且正常运行的游戏客户端。
**要启动 Amazon GameLift Servers 托管的 Amazon EC2 工作流程，请执行以下操作：**
+ 在 Unity 编辑器主菜单中，选择 **Amazon GameLift Servers**，然后选择**通过托管式 EC2 进行托管**。此工作流程提供了集成、构建、部署和启动游戏组件的六步流程。
## 设置配置文件
选择您在遵循此工作流程时要使用的配置文件。您选择的配置文件会影响工作流程中的所有步骤。您创建的所有资源都与个人资料的 AWS 账户相关联，并放置在个人资料的默认 AWS 区域中。个人资料用户的权限决定了您对 AWS 资源和操作的访问权限。
1. 从可用配置文件的下拉列表中选择一个配置文件。如果您还没有个人资料或想要创建新的个人资料，请前往Amazon GameLift Servers菜单并选择 “**设置 AWS 账户资料**”。
1. 如果引导状态不是“活动”，请选择**引导配置文件**并等待状态变为“活动”。
## 将您的游戏与 Amazon GameLift Servers 集成
对于此任务，您需要更新游戏项目中的客户端和服务器代码。
+ 游戏服务器必须能够与 Amazon GameLift Servers 服务通信才能接收启动游戏会话的提示、提供游戏会话连接信息和报告状态。
+ 游戏客户端必须能够获取有关游戏会话的信息、加入或启动游戏会话以及获取连接信息才能加入游戏。
**注意**
如果您导入了示例游戏，则可以跳过这一步。示例游戏资产已准备好所需的服务器和客户端代码。
### 集成服务器代码
将您自己的游戏项目与自定义场景一起使用时，请使用提供的示例代码将所需的服务器代码添加到您的游戏项目。如果您已将游戏项目与 Anywhere 实例集集成以进行测试，您就已经完成此步骤中的指令。
1. 在您的游戏项目文件中，打开 `Assets/Scripts/Server` 文件夹。如果该文件夹不存在，请创建它。
1. 前往 [aws/ GitHub ](https://github.com/aws/amazon-gamelift-plugin-unity) 仓库amazon-gamelift-plugin-unity并打开路径。`Samples~/SampleGame/Assets/Scripts/Server`
1. 找到文件 `GameLiftServer.cs` 并将其复制到游戏项目的 `Server` 文件夹中。构建服务器可执行文件时，请使用此文件作为构建目标。
示例代码包含以下所需的最少元素，这些元素使用了 Amazon GameLift Servers C\$1 服务器 SDK（版本 5）：
+ 初始化 Amazon GameLift Servers API 客户端。Amazon GameLift Servers Anywhere 实例集需要使用服务器参数进行 InitSDK() 调用。这些设置会自动设置，以便在插件中使用。
+ 实施所需的回调函数以响应来自 Amazon GameLift Servers 服务的请求，包括 `OnStartGameSession`、`OnProcessTerminate`、和 `onHealthCheck`。
+ 当服务器进程准备好托管游戏会话时，请使用指定端口调用 `ProcessReady()` 以通知 Amazon GameLift Servers 服务。
如果要自定义示例服务器代码，请参阅以下资源：
+ [借助服务器 SDK 将 Amazon GameLift Servers 添加到游戏服务器](gamelift-sdk-server-api.md)
+ [适用于 Amazon GameLift Servers 的 C\$1 服务器 SDK 5.x – 操作](integration-server-sdk5-csharp-actions.md)
### 集成客户端代码
对于连接到基于云的游戏服务器的游戏客户端，最佳实践是使用客户端后端服务对 Amazon GameLift Servers 服务进行调用，而不是直接从游戏客户端进行调用。
在托管在托管式 EC2 实例集上的插件工作流程中，每个部署方案都包含一个预先构建的后端服务，其中包含以下组件：
+ 一组 Lambda 函数和 DynamoDB 表，用于请求游戏会话和检索游戏会话信息。这些组件使用 API 网关作为代理。
+ 一个 Amazon Cognito 用户池，用于生成唯一玩家 IDs 并对玩家连接进行身份验证。
要使用这些组件，游戏客户端需要能够向后端服务发送执行以下操作的请求：
+ 在 C AWS ognito 用户池中创建玩家用户并进行身份验证。
+ 加入游戏会话并接收连接信息。
+ 使用对战加入游戏。
请使用以下资源作为指南。
+ 将客户端与 GitHub repo 中的[ GameLiftCoreApi](https://github.com/aws/amazon-gamelift-plugin-unity/blob/main/Runtime/GameLiftCoreApi.cs)类集成 [aw amazon-gamelift-plugin-unity](https://github.com/aws/amazon-gamelift-plugin-unity) s/。该类提供了用于玩家身份验证和检索游戏会话信息的控件。
+ 要查看示例游戏集成，请访问 GitHub repo [aw amazon-gamelift-plugin-unity](https://github.com/aws/amazon-gamelift-plugin-unity) s/，。`Samples~/SampleGame/Assets/Scripts/Client/GameLiftClient.cs`
+ [集成 Amazon GameLift Servers 游戏客户端功能](gamelift-sdk-client-api.md).
### （仅限 Unity 6.3\$1）集成 install.sh 脚本
Linux 上的 Unity 6.3 需要 glibc 2.35。亚马逊 Linux 2023 包括 glibc 2.34。提供了一个 install.sh 脚本，用于处理从源代码构建 glibc 2.35 以及将 Unity 二进制文件配置为使用 glibc 2.35。
1. 前往 [aws/ GitHub ](https://github.com/aws/amazon-gamelift-plugin-unity) 仓库amazon-gamelift-plugin-unity并打开路径。`ExtraServerResources`
1. 找到该文件`install.sh`并将其复制到包含您的服务器版本的文件夹中。
1. 如果您已有脚本`install.sh`，请将两个脚本的内容合并为一个`install.sh`。
## 选择部署方案
在此步骤中，您可以选择此时要部署的游戏托管解决方案。使用任何方案，您都可以对游戏进行多个部署。
+ **单区域队列：**将您的游戏服务器部署到活动配置文件默认 AWS 区域中的单个托管资源队列。此场景是测试服务器与服务器版本配置的集成 AWS 和服务器版本配置的良好起点。它部署了以下资源：
+ 已安装并运行游戏服务器构建的AWS 实例集（按需型）。
+ Amazon Cognito 用户群体和客户端，使玩家能够进行身份验证和开始游戏。
+ 与 APIs用户池关联的 API 网关授权器。
+ Web ACl 用于限制玩家对 API 网关的过多调用。
+ API 网关 \$1 Lambda 函数，供玩家申请游戏位置。如果两者都不可用，则此函数调用 `CreateGameSession()`。
+ API 网关 \$1 Lambda 函数，供玩家获取游戏请求的连接信息。
+ **FlexMatch 舰队：**将你的游戏服务器部署到一组舰队中，并设置一个带有规则的 FlexMatch 匹配器来创建玩家对战。此方案使用低成本的竞价型托管和一个多实例集、多位置结构，以实现持久可用性。当您准备好开始为托管解决方案设计对战构建器组件时，此方法非常有用。在这种方案下，您将为此解决方案创建基本资源，并可以根据需要后续对其进行自定义。它部署了以下资源：
+ FlexMatch 配对配置和配对规则设置为接受玩家请求和表单匹配。
+ 三个 AWS 实例集，安装了游戏服务器构建，并在多个位置运行。包括两个竞价型实例集和一个按需型实例集作为备份。
+ AWS 游戏会话放置队列，通过寻找尽可能好的托管资源（基于可行性、成本、玩家延迟等）并启动游戏会话来满足对提议对战的请求。
+ Amazon Cognito 用户群体和客户端，使玩家能够进行身份验证和开始游戏。
+ 与 APIs用户池关联的 API 网关授权器。
+ Web ACl 用于限制玩家对 API 网关的过多调用。
+ API 网关 \$1 Lambda 函数，供玩家申请游戏位置。此函数调用 `StartMatchmaking()`。
+ API 网关 \$1 Lambda 函数，供玩家获取游戏请求的连接信息。
+ Amazon DynamoDB 表，用于存储玩家的对战票证和游戏会话信息。
+ SNS 主题 \$1 用于处理事件的 Lambda 函数。 GameSessionQueue
## 设置游戏参数
在此步骤中，您将描述要上传到的游戏 AWS。
+ **游戏名称：**为游戏项目提供一个有意义的名称。此名称在插件中使用。
+ **实例集名称：**为托管式 EC2 实例集提供一个有意义的名称。Amazon GameLift Servers 在 AWS 控制台中列出资源时会使用此名称（以及实例集 ID）。
+ **版本名称：**为您的服务器版本提供一个有意义的名称。 AWS 使用此名称来指代已上传到Amazon GameLift Servers并用于部署的服务器版本的副本。
+ **启动参数：**输入在托管式 EC2 实例集实例上启动服务器可执行文件时要运行的可选指令。最大长度为 1024 个字符。
+ **游戏服务器文件夹：**提供包含服务器生成包的本地文件夹的路径。
+ **游戏服务器文件：**指定服务器可执行文件的名称。
## 部署方案
在此步骤中，您将根据所选的部署方案将游戏部署到云托管解决方案。在 AWS 验证服务器生成包、预置托管资源、安装游戏服务器、启动服务器进程以及让它们做好托管游戏会话的准备时，此过程可能需要数分钟。
要开始部署，请选择**部署 CloudFormation**。您可以在此处跟踪您的游戏托管状态。要了解更多详细信息，您可以登录 AWS 管理控制台查看 AWS 和查看事件通知。请务必使用与插件中活跃用户个人资料相同的账户、用户和 AWS 地区登录。
部署完成后，您的游戏服务器将安装在 AWS EC2 实例上。至少有一个服务器进程正在运行并准备开始游戏会话。
## 启动游戏客户端
成功部署实例集后，您的游戏服务器就会开始运行，并可用于托管游戏会话。现在，您可以构建客户端、启动客户端、连接以加入游戏会话。
1. 配置游戏客户端。在此步骤中，您将提示插件更新游戏项目的 `GameLiftClientSettings` 资产。插件将使用该资产来存储游戏客户端连接到 Amazon GameLift Servers 服务所需的某些信息。
1. 如果您没有导入和初始化示例游戏，请创建一个新的 `GameLiftClientSettings` 资产。在 Unity 编辑器主菜单中，选择**资产、创建、Amazon GameLift、客户端设置**。如果您在项目中创建了多个 `GameLiftClientSettings` 副本，插件会自动检测到这一点，并通知您插件将更新哪个资产。
1. 在**启动游戏**中，选择**配置客户端：应用托管式 EC2 设置**。此操作将更新游戏客户端设置，以使用您刚刚部署的托管式 EC2 实例集。
1. 构建游戏客户端。使用标准 Unity 构建流程构建客户端可执行文件。在“文件”、“构建设置”中，将平台切换为 Windows、Mac 或 Linux。如果您导入了示例游戏并初始化了设置，则构建列表和构建目标会自动更新。
1. 启动新构建的游戏客户端可执行文件。要开始玩游戏，请启动两到四个客户端实例，并在每个实例中使用 UI 以加入游戏会话。
如果您使用的是示例游戏客户端，那么它具有以下特征：
+ 一个玩家登录组件。连接到 Anywhere 实例集上的游戏服务器时，不会进行玩家验证。您可以输入任意值来加入游戏会话。
+ 一个简单的加入游戏 UI。当一个客户端尝试加入游戏时，该客户端会自动查找有可用玩家位置的活动游戏会话。如果没有可用的游戏会话，该客户端会请求新的游戏会话。如果有可用的游戏会话，该客户端会请求加入该游戏会话。使用多个并发客户端来测试游戏时，第一个客户端会启动游戏会话，其余客户端会自动加入现有的游戏会话。
+ 有四个玩家位置的游戏会话。您最多可以同时启动四个游戏客户端实例，它们将加入同一游戏会话。
# 适用于 Unity 的插件：将游戏部署到托管式容器实例集
使用此引导式插件工作流程为您的游戏服务器创建容器映像，并将其部署到基于容器的托管解决方案。成功完成此工作流程后，您的容器化游戏服务器将在云中运行，您可以使用该插件启动游戏客户端、连接到游戏会话和玩游戏。
## 开始之前
此工作流程假定您已完成以下任务。
+ **将游戏服务器代码与 Amazon GameLift Servers 服务器 SDK 集成。**我们的托管游戏服务器必须能够与 Amazon GameLift Servers 服务通信，以便能够响应启动新游戏会话和报告游戏会话状态的请求。如果您尚未完成此任务，建议您先按照“通过 Anywhere 托管”插件工作流程进行操作。有关准备游戏服务器代码的指导，请参阅[集成服务器代码](unity-plug-in-anywhere.md#unity-plug-in-anywhere-integrate-server)。对于托管式容器实例集，必须将游戏与服务器 SDK 5.2 版或更高版本集成。
**注意**
如果您导入了示例游戏，则此任务已为您完成。
+ **将游戏服务器可执行文件打包，以便在 Linux 上运行。**
+ **收集要与游戏服务器生成包一起部署的文件。**在本地计算机上，创建一个工作目录来整理将内置到游戏服务器容器映像中的文件。这些文件可能包括游戏依赖项、启动游戏服务器的脚本以及启动容器时的其他进程等。
+ **将游戏客户端代码与 Amazon GameLift Servers 集成。**要完成此任务，其中一种方法是添加已集成的示例资产（包含在插件中）。有关准备游戏客户端代码的指导，请参阅[集成客户端代码](unity-plug-in-anywhere.md#unity-plug-in-anywhere-integrate-client)。
+ **在本地计算机上安装 Docker。**如果您希望插件为您创建容器映像并将其推送到 ECR 存储库，则需要安装此工具。或者，您可以手动执行这些任务，并指示插件使用现有的容器映像。有关手动构建映像的更多信息，请参阅[为 Amazon GameLift Servers 构建容器映像](https://docs.aws.amazon.com/gameliftservers/latest/developerguide/containers-prepare-images.html)。
**要启动 Amazon GameLift Servers 托管式容器工作流程，请执行以下操作：**
+ 在 Unity 编辑器主工具栏中，选择 Amazon GameLift Servers 菜单，然后选择**托管式容器**。此操作将打开插件页面 “**使用托管容器托管**”，该页面显示了使用游戏服务器版本创建容器镜像、将其部署到容器队列以及启动游戏的 step-by-step过程。
## 第 0 步：设置您的个人资料
此部分显示您当前选择的用户配置文件。请确认当前的用户配置文件就是您希望在此工作流程中使用的配置文件。您在此工作流程中创建的所有资源都与个人资料的 AWS 帐户相关联，并放置在配置文件的默认 AWS 区域中。个人资料用户的权限决定了您对 AWS 资源和操作的访问权限。
在以下情况下，您可能需要修改所选的用户配置文件：
+ 当前未选择任何配置文件。
+ 您想要选择其他配置文件或创建新的配置文件。
+ 您需要引导所选的配置文件（如果引导状态为非活动）。
**设置或更改所选用户配置文件**
+ 在Amazon GameLift Servers菜单中，选择**开放 AWS 访问凭证**。
## 第 1 步：评测容器就绪情况
在将游戏服务器部署到容器实例集之前，必须将其打包成容器映像并存储在 Amazon ECR 存储库中。该插件可以为您完成这些任务，或者您也可以手动完成这些任务。在此步骤中，提供有关您的容器映像和 ECR 存储库状态的信息。
使用评测问题告知插件，它需要采取哪些步骤：
+ **创建新的容器映像。**如果您选择此选项，下一步将提示您输入游戏服务器生成包目录和生成包可执行文件的位置。该插件使用 Dockerfile 模板（由 Amazon GameLift Servers 提供），并自动为您的游戏配置该模板。您可以参阅[为 Amazon GameLift Servers 构建容器映像](containers-prepare-images.md)，以查看该模板。选择此选项后，请指明您希望插件存储新映像的位置：
+ 创建一个新的 Amazon ECR 存储库，并将容器映像推送到该存储库。该插件使用您选择的用户个人资料 AWS 区域 中的 AWS 帐户和默认帐户创建私有 ECR 存储库。
+ 将容器映像推送到之前创建的 Amazon ECR 存储库。如果您选择此选项，下一步将提示您从列表中选择现有的 Amazon ECR 存储库。该列表包括该 AWS 账户的所有 Amazon ECR 存储库，并且默认出现在您选择的用户个人资料 AWS 区域 中。您可以选择公有存储库或私有存储库。
+ **使用现有的容器映像。**如果您手动构建了映像，我们建议您使用 Amazon GameLift Servers 提供的 Dockerfile 模板，该模板可在[为 Amazon GameLift Servers 构建容器映像](containers-prepare-images.md)中获取。选择此选项后，请指明映像的位置。
+ 本地存储的 Docker 生成的映像。如果您选择此选项，该插件会创建一个新的 Amazon ECR 私有存储库，并将本地映像文件推送到该存储库。下一步将提示您输入映像 ID，插件会使用该 ID 来找到映像文件。
+ 已存储在 Amazon ECR 存储库中的容器映像。如果您选择此选项，下一步将提示您从列表中选择现有的 Amazon ECR 存储库和映像。该列表包括该 AWS 账户的所有 Amazon ECR 存储库，并且默认出现在您选择的用户个人资料 AWS 区域 中。您可以选择公有存储库或私有存储库。
+ Linux 上的 Unity 6.3 需要 glibc 2.35。亚马逊 Linux 2023 包括 glibc 2.34。下面提供了一个 Dockerfile 模板，用于从源代码构建 glibc 2.35 以及将 Unity 二进制文件配置为使用 glibc 2.35。
### Unity 6.3 游戏服务器容器镜像的 Dockerfile 模板
此模板包含游戏服务器容器要在 Amazon GameLift Servers 实例集中可用所需的最少指令。根据需要修改游戏服务器的内容。
```
# Base image
# ----------
# Add the base image that you want to use over here,
# Make sure to use an image with the same architecture as the
# Instance type you are planning to use on your fleets.
FROM public.ecr.aws/amazonlinux/amazonlinux
# Game build directory
# --------------------
# Add your game build directory in the 'GAME_BUILD_DIRECTORY' env variable below.
#
# Game executable
# ---------------
# Add the relative path to your executable in the 'GAME_EXECUTABLE' env variable below.
# The game build provided over here needs to be integrated with gamelift server sdk.
# This template assumes that the executable path is relative to the game build directory.
#
# Launch parameters
# -----------------
# Add any launch parameters to pass into your executable in the 'LAUNCH_PARAMS' env variable below.
#
# Default directory
# -----------------
# The value provided in 'HOME_DIR' below will be where the game executable and logs exist.
#
ARG GAME_BUILD_DIRECTORY
ARG GAME_EXECUTABLE
ARG LAUNCH_PARAMS
ENV GAME_BUILD_DIRECTORY=$GAME_BUILD_DIRECTORY \
GAME_EXECUTABLE=$GAME_EXECUTABLE \
LAUNCH_PARAMS=$LAUNCH_PARAMS \
HOME_DIR="/local/game"
# install dependencies as necessary
RUN yum install -y shadow-utils bison wget gcc make patchelf tar gzip && \
yum clean all && rm -fr /var/cache
RUN mkdir -p $HOME_DIR
COPY .$GAME_BUILD_DIRECTORY/ $HOME_DIR
# Change directory to home
WORKDIR $HOME_DIR
# Build glibc 2.35 and patch Unity binaries
RUN GLIBC_VERSION="2.35" && \
INSTALL_PREFIX="/opt/glibc-${GLIBC_VERSION}" && \
ARCH=$(uname -m) && \
if [ "$ARCH" = "x86_64" ]; then \
INTERPRETER="${INSTALL_PREFIX}/lib/ld-linux-x86-64.so.2"; \
MONO_ARCH="x86_64"; \
elif [ "$ARCH" = "aarch64" ]; then \
INTERPRETER="${INSTALL_PREFIX}/lib/ld-linux-aarch64.so.1"; \
MONO_ARCH="aarch64"; \
else \
echo "ERROR: Unsupported architecture: $ARCH"; exit 1; \
fi && \
cd /tmp && \
wget -q "https://ftp.gnu.org/gnu/glibc/glibc-${GLIBC_VERSION}.tar.gz" && \
tar -xzf "glibc-${GLIBC_VERSION}.tar.gz" && \
cd "glibc-${GLIBC_VERSION}" && mkdir glibc-build && cd glibc-build && \
touch /etc/ld.so.conf && \
../configure --prefix="${INSTALL_PREFIX}" && \
make -s all && make -s install && \
cd / && rm -rf /tmp/glibc-* && \
GLIBC_LIB="${INSTALL_PREFIX}/lib" && \
EXECUTABLE_NAME=$(echo "$GAME_EXECUTABLE" | sed 's/\.[^.]*$//') && \
DATA_DIR="$HOME_DIR/${EXECUTABLE_NAME}_Data" && \
patchelf --set-interpreter "$INTERPRETER" "$HOME_DIR/$GAME_EXECUTABLE" && \
patchelf --set-rpath "$GLIBC_LIB:$HOME_DIR:/lib64:$DATA_DIR/MonoBleedingEdge/$MONO_ARCH" "$HOME_DIR/$GAME_EXECUTABLE" && \
patchelf --set-rpath "$GLIBC_LIB:/lib64" "$HOME_DIR/UnityPlayer.so" && \
MONO_LIB="$DATA_DIR/MonoBleedingEdge/$MONO_ARCH/libmonobdwgc-2.0.so" && \
if [ -f "$MONO_LIB" ]; then patchelf --set-rpath "$GLIBC_LIB:/lib64" "$MONO_LIB"; fi && \
GAME_ASSEMBLY="$HOME_DIR/GameAssembly.so" && \
if [ -f "$GAME_ASSEMBLY" ]; then patchelf --set-rpath "$GLIBC_LIB:/lib64" "$GAME_ASSEMBLY"; fi
RUN useradd -m gamescale && \
echo "gamescale ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers && \
chown -R gamescale:gamescale $HOME_DIR
# Add permissions to game build
RUN chmod +x ./$GAME_EXECUTABLE
USER gamescale
# Check directory before starting the container
RUN ls -lhrt .
# Check path before starting the container
RUN echo $PATH
# Start the game build
ENTRYPOINT ["/bin/sh", "-c", "./$GAME_EXECUTABLE $LAUNCH_PARAMS"]
```
## 第 2 步：配置映像部署
在此步骤中，提供插件将您的容器映像部署到容器实例集所需的信息。此步骤要求提供以下信息：
+ 您的游戏服务器生成包、容器映像或 Amazon ECR 存储库的位置，具体取决于您在第 1 步中的选择。
+ 用于托管式容器部署的方案。
+ 可选部署设置。此部分包含插件默认使用的配置设置。您可以修改这些设置，也可以保留默认值
+ 默认情况下，游戏名称设置为游戏项目的名称。插件创建的所有 AWS 资源都引用游戏名称值。
+ 端口范围、内存限制和 vCPU 限制是容器实例集的配置设置。有关自定义这些值的更多信息，请参阅[配置网络连接](containers-design-fleet.md#containers-custom-network)以了解连接端口范围，并参阅[设置资源限制](containers-design-fleet.md#containers-design-fleet-limits)以了解资源限制。
+ 容器映像标签用于在 Amazon ECR 中对容器映像进行分类。默认值为 `unity-gamelift-plugin`。
### 部署方案选项
#### 单区域容器实例集
此方案将您的游戏服务器部署到单个容器实例集。它是测试服务器与 AWS 集成和容器配置的良好起点。它部署了以下资源：
+ Amazon GameLift Servers 容器组定义，描述了如何在容器实例集上部署和运行您的容器映像。
+ 已安装并运行您的游戏服务器容器的 Amazon GameLift Servers 容器实例集（按需型），附带别名。
+ Amazon Cognito 用户群体和客户端，使玩家能够进行身份验证和开始游戏。
+ 将用户池与 APIs关联的 API Gateway 授权方。
+ Web 访问控制列表（ACL），用于限制玩家对 API 网关的过多调用。
+ 代表游戏客户端向 Amazon GameLift Servers 服务发出请求的后端服务，例如请求游戏会话和加入游戏：
+ API 网关 \$1 Lambda 函数，供玩家申请游戏会话位置。如果没有可用的空闲位置，则此函数调用 `CreateGameSession()`。
+ API 网关 \$1 Lambda 函数，供玩家获取游戏请求的连接信息。
#### 包含 FlexMatch 的单区域容器实例集
此方案将您的游戏服务器部署到容器实例集、配置游戏会话放置并设置 FlexMatch 对战。当您准备开始为托管解决方案设计自定义配对器时，此方案非常有用。使用此方案时，您将为该解决方案创建基本资源，并可以根据需要后续对其进行自定义。它部署了以下资源：
+ Amazon GameLift Servers 容器组定义，描述了如何在容器实例集上部署和运行您的容器映像。
+ 已安装并运行您的游戏服务器容器的 Amazon GameLift Servers 容器实例集（按需型），附带别名。
+ FlexMatch 对战配置和对战规则设置为接受玩家请求和组成对战。
+ Amazon GameLift Servers 游戏会话队列，通过寻找尽可能好的托管资源（基于可行性、成本、玩家延迟等）并启动游戏会话来满足对提议对战的请求。
+ Amazon Cognito 用户群体和客户端，使玩家能够进行身份验证和开始游戏。
+ 将用户池与 APIs关联的 API Gateway 授权方。
+ Web 访问控制列表（ACL），用于限制玩家对 API 网关的过多调用。
+ 代表游戏客户端向 Amazon GameLift Servers 服务发出请求的后端服务，例如请求游戏会话和加入游戏：
+ API 网关 \$1 Lambda 函数，供玩家申请游戏会话位置。如果没有可用的空闲位置，则此函数调用 `StartMatchmaking()`。
+ API 网关 \$1 Lambda 函数，供玩家获取游戏请求的连接信息。
+ DynamoDB 表，用于存储玩家的对战票证和游戏会话信息。
+ 亚马逊 SNS 主题 \$1 用于处理事件的 Lambda 函数。 GameSessionQueue
## 部署容器实例集
实例集配置完成后，选择**部署容器实例集**按钮以开始部署。插件将创建容器映像并将其推送到 ECR，为容器实例集预调配托管资源，并为所选托管解决方案场景部署实例集和其他 AWS 资源，整个过程可能需要几分钟。
开始部署时，您可以跟踪每个步骤的进度。根据您的配置，步骤可能包括以下内容：
+ 配置容器映像
+ 创建新的 Amazon ECR 存储库
+ 构建映像并推送到 Amazon ECR
+ 创建容器组定义
+ 创建容器实例集
有关更详细的部署信息，请选择**在 AWS 管理控制台中查看**。当容器实例集达到活动状态时，即表示实例集正在主动运行容器，其中的服务器进程已准备好托管游戏会话。
部署完成后，您将拥有一个正常运行的容器实例集，随时可以托管游戏会话并接受玩家连接。
您无法停止正在进行的部署。如果部署进入不良状态或失败，您可以使用**重置部署**选项重新开始。
## 启动客户端
至此，您已经完成了启动和玩使用 Amazon GameLift Servers 托管的多人游戏所需的所有任务。要玩游戏，请选择**启动客户端**以启动游戏客户端的本地实例。
+ 如果您部署了单个实例集方案，请打开一个包含一名玩家的游戏客户端实例，然后进入服务器地图并进行移动操作。您可以打开游戏客户端的第二个实例，将第二名玩家添加到同一个服务器游戏地图中。
+ 如果您部署了 FlexMatch 方案，则托管解决方案会等待至少两个游戏客户端发出对战请求。打开至少两个游戏客户端实例，每个实例各包含一名玩家。这两名玩家将进行匹配，并收到加入游戏会话以进行对战的提示。
## 更新容器实例集
如果您已成功部署托管式容器托管解决方案，可以使用**更新部署**功能。此选项可让您更新已部署容器实例集的配置设置，而无需创建新的实例集。
更新部署时，您可以部署包含不同游戏服务器生成包的容器映像，更改 Amazon ECR 存储库，选择不同的部署方案，以及自定义可选配置设置。
如果您已准备好部署更改，请选择“更新”。部署更新所需的时间与全面部署所需的时间类似。要了解详细的部署信息，请选择**在 AWS 管理控制台中查看**。
## 清理已部署的资源
作为最佳实践，请在不再需要托管容器解决方案时立即清理这些 AWS 资源。如果不删除这些资源，它们可能会继续产生费用。
请删除以下资源：
+ 托管式容器资源堆栈。此堆栈中的资源取决于您选择的部署方案。要删除整个堆栈，请使用 CloudFormation 控制台。从 Amazon GameLift Servers 插件生成的堆栈使用以下命名规范：`GameLiftPluginForUnity-{GameName}-Containers`。在插件中启动新的托管式容器部署之前，请等待堆栈删除过程完成。有关更多信息，请参阅[从 CloudFormation 控制台删除堆栈](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-delete-stack.html)。
+ Amazon ECR 存储库。如果您使用插件为容器映像创建了存储库，可能需要删除所有不再需要的存储库。在重置托管式容器部署之前，无需删除存储库。如果您更新或重置部署，除非指示使用其他存储库，否则插件将自动使用同一个存储库。有关更多信息，请参阅[在 Amazon ECR 中删除私有存储库](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-delete.html)。
# 适用于 Unity 的 Amazon GameLift Servers 插件（服务器 SDK 4）
**注意**
本主题提供了适用于 Unity 的 Amazon GameLift Servers 插件的早期版本相关信息。版本 1.x 使用适用于 Amazon GameLift Servers 4.x 或更早版本的服务器 SDK。有关插件最新版本（使用服务器 SDK 5.x 并支持 Amazon GameLift Servers Anywhere 和托管式容器托管等新功能）的文档，请参阅[Amazon GameLift Servers适用于 Unity 的插件（服务器 SDK 5.x）](unity-plug-in.md)。
Amazon GameLift Servers 提供一些工具，用于让您的多人游戏服务器准备就绪，从而在 Amazon GameLift Servers 上运行。借助适用于 Unity 的 Amazon GameLift Servers 插件，您可以更轻松地将 Amazon GameLift Servers 集成到 Unity 游戏项目中并部署 Amazon GameLift Servers 资源进行云托管。使用 Unity 插件访问Amazon GameLift Servers APIs 和部署常见游戏场景的 AWS CloudFormation 模板。
设置插件后，您可以试用 [Amazon GameLift ServersUnity 示例](https://github.com/aws-samples/amazon-gamelift-unity) GitHub。
**Topics**
+ [将 Amazon GameLift Servers 与 Unity 游戏服务器项目集成](integration-unity-server-sdk4.md)
+ [将 Amazon GameLift Servers 与 Unity 游戏客户端项目集成](integration-unity-client-sdk4.md)
+ [安装并设置插件](#unity-plug-in-sdk4-install)
+ [在本地测试游戏](#unity-plug-in-sdk4-test)
+ [部署场景](#unity-plug-in-sdk4-scenario)
+ [在 Unity 中将游戏与 Amazon GameLift Servers 集成](#unity-plug-in-sdk4-integration-intro)
+ [导入并运行示例游戏](#unity-plug-in-sdk4-sample-game)
# 将 Amazon GameLift Servers 与 Unity 游戏服务器项目集成
**注意**
本主题提供了适用于 Unity 的 Amazon GameLift Servers 插件的早期版本相关信息。版本 1.x 使用适用于 Amazon GameLift Servers 4.x 或更早版本的服务器 SDK。有关插件最新版本（使用服务器 SDK 5.x 并支持 Amazon GameLift Servers Anywhere 和托管式容器托管等新功能）的文档，请参阅[Amazon GameLift Servers适用于 Unity 的插件（服务器 SDK 5.x）](unity-plug-in.md)。
本主题可帮助您将托管在 Amazon GameLift Servers 上的自定义游戏服务器准备就绪。游戏服务器必须能够通知 Amazon GameLift Servers 自身状态，在提示时开始和停止游戏会话，以及执行其他任务。有关更多信息，请参阅 [借助服务器 SDK 将 Amazon GameLift Servers 添加到游戏服务器](gamelift-sdk-server-api.md)。
## 先决条件
在集成游戏服务器之前，请完成以下任务：
+ [为 Amazon GameLift Servers 设置 IAM 服务角色](setting-up-role.md)
+ [安装并设置插件](unity-plug-in-sdk4.md#unity-plug-in-sdk4-install)
## 设置新的服务器进程
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
设置与 Amazon GameLift Servers 的通信，并报告服务器进程已准备好托管游戏会话。
1. 通过调用 `InitSDK()` 初始化服务器软件开发工具包。
1. 要让服务器做好接受游戏会话的准备，调用 `ProcessReady()` 以及连接端口和游戏会话位置的详细信息。包括 Amazon GameLift Servers 服务调用的回调函数的名称，例如 `OnGameSession()`、`OnGameSessionUpdate()`、`OnProcessTerminate()`、`OnHealthCheck()`。Amazon GameLift Servers 可能需要几分钟来提供回调。
1. Amazon GameLift Servers 将服务器进程的状态更新为 `ACTIVE`。
1. Amazon GameLift Servers 定期调用 `onHealthCheck`。
以下代码示例展示了如何使用 Amazon GameLift Servers 设置简单的服务器进程。
```
//initSDK
var initSDKOutcome = GameLiftServerAPI.InitSDK();
//processReady
// Set parameters and call ProcessReady
var processParams = new ProcessParameters(
this.OnGameSession,
this.OnProcessTerminate,
this.OnHealthCheck,
this.OnGameSessionUpdate,
port,
// Examples of log and error files written by the game server
new LogParameters(new List()
{
"C:\\game\\logs",
"C:\\game\\error"
})
);
var processReadyOutcome = GameLiftServerAPI.ProcessReady(processParams);
// Implement callback functions
void OnGameSession(GameSession gameSession)
{
// game-specific tasks when starting a new game session, such as loading map
// When ready to receive players
var activateGameSessionOutcome = GameLiftServerAPI.ActivateGameSession();
}
void OnProcessTerminate()
{
// game-specific tasks required to gracefully shut down a game session,
// such as notifying players, preserving game state data, and other cleanup
var ProcessEndingOutcome = GameLiftServerAPI.ProcessEnding();
}
bool OnHealthCheck()
{
bool isHealthy;
// complete health evaluation within 60 seconds and set health
return isHealthy;
}
```
## 启动游戏会话
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
游戏初始化完成后，您可以开始游戏会话。
1. 实现回调函数 `onStartGameSession`。Amazon GameLift Servers 调用此方法在服务器进程上启动新的游戏会话并接收玩家连接。
1. 要激活游戏会话，请调用 `ActivateGameSession()`。有关软件开发工具包的更多信息，请参阅[适用于 Amazon GameLift Servers 4.x 的 C\$1 服务器 SDK – 操作](integration-server-sdk-csharp-ref-actions.md)。
以下代码示例说明了如何使用 Amazon GameLift Servers 启动游戏会话。
```
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();
}
```
## 结束游戏会话
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
游戏会话结束时通知 Amazon GameLift Servers。最佳实操是在游戏会话完成后关闭服务器进程，以回收和刷新托管资源。
1. 设置一个名为 `onProcessTerminate` 的函数以接收来自 Amazon GameLift Servers 的请求并调用 `ProcessEnding()`。
1. 进程状态更改为 `TERMINATED`。
以下示例描述了如何结束游戏会话的进程。
```
var processEndingOutcome = GameLiftServerAPI.ProcessEnding();
if (processReadyOutcome.Success)
Environment.Exit(0);
// otherwise, exit with error code
Environment.Exit(errorCode);
```
## 创建服务器生成包并上传到 Amazon GameLift Servers
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
将游戏服务器与 Amazon GameLift Servers 集成后，将生成包文件上传到实例集中，这样 Amazon GameLift Servers 就可以将其部署到游戏托管。有关如何将服务器上传到 Amazon GameLift Servers 的更多信息，请参阅[为 Amazon GameLift Servers 创建游戏服务器生成包](gamelift-build-cli-uploading.md)。
# 将 Amazon GameLift Servers 与 Unity 游戏客户端项目集成
**注意**
本主题提供了适用于 Unity 的 Amazon GameLift Servers 插件的早期版本相关信息。版本 1.x 使用适用于 Amazon GameLift Servers 4.x 或更早版本的服务器 SDK。有关插件最新版本（使用服务器 SDK 5.x 并支持 Amazon GameLift Servers Anywhere 和托管式容器托管等新功能）的文档，请参阅[Amazon GameLift Servers适用于 Unity 的插件（服务器 SDK 5.x）](unity-plug-in.md)。
本主题可帮助您设置游戏客户端，以通过后端服务连接到 Amazon GameLift Servers 托管的游戏会话。Amazon GameLift Servers APIs 用于发起配对、请求游戏会话放置等。
向后端服务项目添加代码，以允许与 Amazon GameLift Servers 服务进行通信。后端服务处理游戏客户端与该 GameLift 服务的所有通信。有关后端服务的更多信息，请参阅。
后端服务器处理以下游戏客户端任务：
+ 自定义玩家身份验证。
+ 从 Amazon GameLift Servers 服务请求有关活动游戏会话的信息。
+ 创建新的游戏会话。
+ 将玩家加入到现有游戏会话。
+ 将玩家从现有游戏会话中移除。
**Topics**
+ [先决条件](#integration-unity-client-sdk4-prereq)
+ [初始化游戏客户端](#integration-unity-client-sdk4-initialize)
+ [按照特定的实例集创建游戏会话](#integration-unity-client-sdk4-game-session)
+ [向游戏会话中添加玩家](#integration-unity-client-sdk4-add-player)
+ [从游戏会中移除玩家](#integration-unity-client-sdk4-remove-player)
## 先决条件
在使用 Amazon GameLift Servers 客户端设置游戏服务器通信前，请完成以下任务：
+ [设置 AWS 用户账户](setting-up-aws-login.md)
+ [安装并设置插件](unity-plug-in-sdk4.md#unity-plug-in-sdk4-install)
+ [将 Amazon GameLift Servers 与 Unity 游戏服务器项目集成](integration-unity-server-sdk4.md)
+ [为 Amazon GameLift Servers 部署托管实例集](fleets-intro.md)
## 初始化游戏客户端
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
添加用于初始化游戏客户端的代码。启动时运行此代码，这是其他 Amazon GameLift Servers 功能的必要条件。
1. 初始化 `AmazonGameLiftClient`。使用默认客户端配置或自定义配置调用 `AmazonGameLiftClient`。有关如何配置客户端的更多信息，请参阅[设置 Amazon GameLift Servers API](gamelift-sdk-client-api.md#gamelift-sdk-client-api-initialize)。
1. 为每个玩家生成唯一的玩家 ID 来连接到游戏会话。有关更多信息，请参阅 [生成玩家 ID](player-sessions-player-identifiers.md)。
以下示例显示了如何设置Amazon GameLift Servers客户端。
```
public class GameLiftClient
{
private GameLift gl;
//A sample way to generate random player IDs.
bool includeBrackets = false;
bool includeDashes = true;
string playerId = AZ::Uuid::CreateRandom().ToString(includeBrackets, includeDashes);
private Amazon.GameLift.Model.PlayerSession psession = null;
public AmazonGameLiftClient aglc = null;
public void CreateGameLiftClient()
{
//Access Amazon GameLift Servers service by setting up a configuration.
//The default configuration specifies a location.
var config = new AmazonGameLiftConfig();
config.RegionEndpoint = Amazon.RegionEndpoint.USEast1;
CredentialProfile profile = null;
var nscf = new SharedCredentialsFile();
nscf.TryGetProfile(profileName, out profile);
AWSCredentials credentials = profile.GetAWSCredentials(null);
//Initialize Amazon GameLift Servers Client with default client configuration.
aglc = new AmazonGameLiftClient(credentials, config);
}
}
```
## 按照特定的实例集创建游戏会话
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
添加用于在已部署的实例集中启动新游戏会话并使其可供玩家接入的代码。在 Amazon GameLift Servers 创建了新游戏会话并返回 `GameSession` 后，便可以向其中添加玩家。
+ 申请新游戏会话。
+ 如果您的游戏使用实例集，请使用实例集或别名 ID、会话名称和游戏的最大并发玩家数量调用 `CreateGameSession()`。
+ 如果您的游戏使用队列，请调用 `StartGameSessionPlacement()`。
以下示例演示如何创建游戏会话。
```
public Amazon.GameLift.Model.GameSession()
{
var cgsreq = new Amazon.GameLift.Model.CreateGameSessionRequest();
//A unique identifier for the alias with the fleet to create a game session in.
cgsreq.AliasId = aliasId;
//A unique identifier for a player or entity creating the game session
cgsreq.CreatorId = playerId;
//The maximum number of players that can be connected simultaneously to the game session.
cgsreq.MaximumPlayerSessionCount = 4;
//Prompt an available server process to start a game session and retrieves connection information for the new game session
Amazon.GameLift.Model.CreateGameSessionResponse cgsres = aglc.CreateGameSession(cgsreq);
string gsid = cgsres.GameSession != null ? cgsres.GameSession.GameSessionId : "N/A";
Debug.Log((int)cgsres.HttpStatusCode + " GAME SESSION CREATED: " + gsid);
return cgsres.GameSession;
}
```
## 向游戏会话中添加玩家
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
在 Amazon GameLift Servers 创建了新游戏会话并返回 `GameSession` 后，便可以向其中添加玩家。
1. 通过新建玩家会话在游戏会话中预留玩家位置。将 `CreatePlayerSession` 或 `CreatePlayerSessions` 与游戏会话 ID 和每个玩家的唯一 ID 一起使用。
1. 连接到游戏会话。检索 `PlayerSession` 对象以获取游戏会话的连接信息。您可以使用此信息与服务器进程建立直接连接：
1. 使用指定的端口以及分配给服务器进程的 DNS 名称或 IP 地址进行连接。
1. 使用实例集的 DNS 名称和端口。如果实例集启用了 TLS 证书生成，则需要 DNS 名称和端口。
1. 引用玩家会话 ID。如果游戏服务器验证传入的玩家连接，则需要玩家会话 ID。
以下示例演示了如何在游戏会话中预留玩家位置。
```
public Amazon.GameLift.Model.PlayerSession CreatePlayerSession(Amazon.GameLift.Model.GameSession gsession)
{
var cpsreq = new Amazon.GameLift.Model.CreatePlayerSessionRequest();
cpsreq.GameSessionId = gsession.GameSessionId;
//Specify game session ID.
cpsreq.PlayerId = playerId;
//Specify player ID.
Amazon.GameLift.Model.CreatePlayerSessionResponse cpsres = aglc.CreatePlayerSession(cpsreq);
string psid = cpsres.PlayerSession != null ? cpsres.PlayerSession.PlayerSessionId : "N/A";
return cpsres.PlayerSession;
}
```
以下代码说明了如何将玩家连接到游戏会话。
```
public bool ConnectPlayer(int playerIdx, string playerSessionId)
{
//Call ConnectPlayer with player ID and player session ID.
return server.ConnectPlayer(playerIdx, playerSessionId);
}
```
## 从游戏会中移除玩家
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
当玩家离开游戏时，您可以将其从游戏会话中移除。
1. 通知 Amazon GameLift Servers 服务，有玩家已断开与服务器进程的连接。使用玩家的会话 ID 调用 `RemovePlayerSession`。
1. 验证 `RemovePlayerSession` 是否返回 `Success`。然后，Amazon GameLift Servers 将玩家位置更改为可用，Amazon GameLift Servers 可以将其分配给新玩家。
以下示例说明了如何移除玩家会话。
```
public void DisconnectPlayer(int playerIdx)
{
//Receive the player session ID.
string playerSessionId = playerSessions[playerIdx];
var outcome = GameLiftServerAPI.RemovePlayerSession(playerSessionId);
if (outcome.Success)
{
Debug.Log (":) PLAYER SESSION REMOVED");
}
else
{
Debug.Log(":(PLAYER SESSION REMOVE FAILED. RemovePlayerSession()
returned " + outcome.Error.ToString());
}
}
```
## 安装并设置插件
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
本节介绍如何下载、安装和设置适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0。
**先决条件**
+ 适用于 Windows 的 Unity 2019.4 LTS、适用于 Windows 的 2020.3 LTS 或适用于 macOS 的 Unity
+ Java 的当前版本
+ .NET 4.x 的当前版本
**下载并安装适用于 Unity 的插件**
1. 下载适用于 Unity 的 Amazon GameLift Servers 插件。您可以在[适用于 Unity 存储库的 Amazon GameLift Servers 插件](https://github.com/aws/amazon-gamelift-plugin-unity/releases)页面上找到最新版本。在[最新版本](https://github.com/aws/amazon-gamelift-plugin-unity/releases)下，选择**资产**，然后下载 `com.amazonaws.gamelift-version.tgz` 文件。
1. 启动 Unity 并选择一个项目。
1. 在顶部导航栏的**窗口**下，选择 **Package Manager**：
![\[“窗口”下的 Unity 菜单，已选择 Package Manager。\]](http://docs.aws.amazon.com/zh_cn/gameliftservers/latest/developerguide/images/unitypi_install_pkgmgr.png)
1. 在 **Package Manager** 选项卡下，选择 **\$1**，然后选择**从 tarball 添加软件包...**：
![\[突出显示了“Package Manager”选项卡中“+”图标下的“从 tarball 添加软件包”。\]](http://docs.aws.amazon.com/zh_cn/gameliftservers/latest/developerguide/images/unitypi_install_tarball.png)
1. 在**选择磁盘上的软件包**窗口中，导航到 `com.amazonaws.gamelift` 文件夹，选择文件 `com.amazonaws.gamelift-version.tgz `，然后选择**打开**：
![\[在“选择磁盘上的软件包”窗口中选择 tarball 文件。\]](http://docs.aws.amazon.com/zh_cn/gameliftservers/latest/developerguide/images/unitypi_install_tarballselect.png)
1. Unity 加载插件后，**Amazon GameLift Servers** 将作为新项目出现在 Unity 菜单中。安装和重新编译脚本可能需要几分钟时间。**Amazon GameLift Servers 插件设置**选项卡会自动打开。
![\[适用于 Unity 的 Amazon GameLift Servers 插件设置菜单。\]](http://docs.aws.amazon.com/zh_cn/gameliftservers/latest/developerguide/images/unitypi_install_done_ui.png)
1. 在**软件开发工具包**窗格中，选择**使用 .NET 4.x**。
配置后，状态将从**未配置**更改为**已配置**。
## 在本地测试游戏
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
使用 Amazon GameLift Servers Local 在本地设备上运行 Amazon GameLift Servers。无需网络连接，即可使用 Amazon GameLift Servers Local 在几秒钟内验证代码更改。
### 配置本地测试
1. 在 Unity 插件窗口中，选择**测试**选项卡。
1. 在**测试**窗格中，选择**下载 Amazon GameLift Servers Local**。适用于 Unity 的插件会打开浏览器窗口，并将 `GameLift_06_03_2021.zip` 文件下载到您的下载文件夹。
下载内容包括 C\$1 服务器软件开发工具包、.NET 源文件和与 Unity 兼容的 .NET 组件。
1. 解压下载的 `GameLift_06_03_2021.zip` 文件。
1. 在 **Amazon GameLift Servers 插件设置**窗口中，选择 **Amazon GameLift Servers Local 路径**，导航到解压缩的文件夹，选择 `GameLiftLocal.jar` 文件，然后选择**打开**。
配置后，本地测试状态将从**未配置**更改为**已配置**。
1. 验证 JRE 的状态。如果状态为**未配置**，请选择**下载 JRE** 并安装推荐的 Java 版本。
安装和配置 Java 环境后，状态将更改为**已配置**。
### 运行本地游戏
1. 在“适用于 Unity 的插件”选项卡中，选择**测试**选项卡。
1. 在**测试**窗格中，选择**打开本地测试 UI**。
1. 在**本地测试**窗口中，指定**服务器可执行文件路径**。选择**...**选择服务器应用程序的路径和可执行文件名称。
1. 在**本地测试**窗口中，指定 **GL Local 端口**。
1. 选择**部署并运行**以部署和运行服务器。
1. 要停止游戏服务器，请选择**停止**或关闭游戏服务器窗口。
## 部署场景
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
场景使用 CloudFormation 模板来创建为游戏部署云托管解决方案所需的资源。本节介绍 Amazon GameLift Servers 提供的场景及其使用方法。
**先决条件**
要部署该场景，您需要为 Amazon GameLift Servers 服务创建一个 IAM 角色。有关如何为 Amazon GameLift Servers 创建角色的信息，请参阅[设置 AWS 用户账户](setting-up-aws-login.md)。
每种场景都需要访问以下资源的权限：
+ Amazon GameLift Servers
+ Amazon S3
+ CloudFormation
+ API Gateway
+ AWS Lambda
+ AWS WAFV2
+ Amazon Cognito
### 场景
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
适用于 Unity 的 Amazon GameLift Servers 插件包括以下场景：
**仅限身份验证**
此场景创建了一个游戏后端服务，该服务在没有游戏服务器功能的情况下执行玩家身份验证。该模板在您的账户中创建以下资源：
+ Amazon Cognito 用户群体，用于存储玩家身份验证信息。
+ Amazon API Gateway REST 端点支持的 AWS Lambda 处理程序，用于启动游戏并查看游戏连接信息。
**单区域实例集**
此场景创建了一个包含单个 Amazon GameLift Servers 实例集的游戏后端服务。其创建了以下资源：
+ Amazon Cognito 用户群体，供玩家进行身份验证和开始游戏。
+ 一个 AWS Lambda 处理程序，用于搜索舰队上有开放玩家槽位的现有游戏会话。如果该处理程序找不到开放位置，就会创建一个新的游戏会话。
**带有队列和自定义对战构建器的多区域实例集**
此场景使用 Amazon GameLift Servers 队列和自定义对战构建器将等候池中等待时间最长的玩家分组在一起，从而形成对战。其创建了以下资源：
+ Amazon Simple Notification Service 主题，Amazon GameLift Servers 可向其发布消息。有关 SNS 主题和通知的更多信息，请参阅 [请参阅设置游戏会话置放通知。](queue-notification.md)。
+ 一个 Lambda 函数，由传达位置和游戏连接详情的消息调用。
+ Amazon DynamoDB 表，用于存储位置和游戏连接详情。`GetGameConnection` 调用从此表读取并将连接信息返回到游戏客户端。
**带有队列和自定义对战构建器的竞价型实例集**
此场景使用 Amazon GameLift Servers 队列和自定义对战构建器形成对战，并配置三个实例集。其创建了以下资源：
+ 两个竞价型实例集包含不同的实例类型，可确保竞价型实例不可用性更持久。
+ 一种按需型实例集，可作为其他竞价型实例集的备份。有关实例集设计的更多信息，请参阅[托管资源自定义](fleets-design.md)。
+ 用于保持服务器高可用性和低成本的Amazon GameLift Servers队列。有关队列的更多信息和最佳实操，请参阅[自定义游戏会话队列](queues-design.md)。
**FlexMatch**
此场景使用 FlexMatch托管配对服务将玩家配对在一起。有关 FlexMatch 的更多信息，请参阅[什么是 Amazon GameLift ServersFlexMatch](https://docs.aws.amazon.com/gameliftservers/latest/flexmatchguide/match-intro.html)。此场景创建了以下资源：
+ 一个 Lambda 函数，用于在收到 `StartGame` 请求后创建对战票证。
+ 一个单独的 Lambda 函数，用于侦听 FlexMatch 匹配事件。
为避免对您产生不必要的费用 AWS 账户，请在使用完每个场景创建的资源后将其删除。删除相应的 CloudFormation 堆栈。
### 更新 AWS 凭证
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
适用于 Unity 的 Amazon GameLift Servers 插件需要安全凭证才能部署场景。您可以创建新凭证或使用现有凭证。
有关配置凭证的更多信息，请参阅[了解和获取您的 AWS 证书](https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html)。
**更新 AWS 凭证**
1. 在 Unity 的“适用于 Unity 的插件”选项卡中，选择**部署**选项卡。
1. 在**部署**窗格中，选择 **AWS 凭证**。
1. 您可以创建新 AWS 凭证或选择现有证书。
+ 要创建凭证，请选择**创建新的凭证配置文件**，然后指定**新配置文件名称**、**AWS 访问密钥 ID**、**AWS 密钥**和 **AWS 区域**。
+ 要选择现有凭证，请选择**选择现有凭证配置文件**，然后选择配置文件名称和 **AWS 区域**。
1. 在 “**更新 AWS 凭据**” 窗口中，选择 “**更新凭据配置文件**”。
### 更新账户引导程序
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
引导位置是部署期间使用的 Amazon S3 存储桶。它用于存储游戏服务器资产和其他依赖项。 AWS 区域 您为存储桶选择的区域必须与用于场景部署的区域相同。
有关 Amazon S3 存储桶的更多信息，请参阅[创建、配置和使用 Amazon Simple Storage Service 存储桶](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html)。
**更新账户引导位置**
1. 在 Unity 的“适用于 Unity 的插件”选项卡中，选择**部署**选项卡。
1. 在**部署**窗格中，选择**更新账户引导**。
1. 在**账户引导**窗口中，您可以选择现有 Amazon S3 存储桶或创建一个新的 Amazon S3 存储桶：
+ 要选择现有存储桶，请选择**选择现有 Amazon S3 存储桶**，然后选择**更新**以保存您的选择。
+ 选择**创建新的 Amazon S3 存储桶**以创建新的 Amazon Simple Storage Service 存储桶，然后选择**策略**。该策略指定了 Amazon S3 存储桶的过期时间。选择**创建**以创建存储桶。
### 部署游戏场景
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
您可以使用场景在 Amazon GameLift Servers 上测试您的游戏。每个场景都使用 CloudFormation 模板创建一个包含所需资源的堆栈。大多数场景都需要游戏服务器可执行文件和构建路径。部署场景时，Amazon GameLift Servers 会将游戏资产复制到引导位置，作为部署的一部分。
您必须配置 AWS 凭据和 AWS 账户引导才能部署方案。
**部署场景**
1. 在 Unity 的“适用于 Unity 的插件”选项卡中，选择**部署**选项卡。
1. 在**部署**窗格中，选择**打开部署 UI**。
1. 在**部署**窗口中，选择一个场景。
1. 输入**游戏名称**。此名称必须唯一。部署场景时，游戏名称是 CloudFormation 堆栈名称的一部分。
1. 选择**游戏服务器构建文件夹路径**。构建文件夹路径指向包含服务器可执行文件和依赖项的文件夹。
1. 选择**游戏服务器构建 .exe 文件路径**。构建可执行文件路径指向游戏服务器可执行文件。
1. 选择**开始部署**以开始部署场景。您可以在**部署**窗口的**当前状态**下关注更新状态。部署场景可能需要数分钟。
![\[场景部署状态更新\]](http://docs.aws.amazon.com/zh_cn/gameliftservers/latest/developerguide/images/unitypi_deploy_statex.png)
1. 场景完成部署后，**当前状态**将更新为包括 **Cognito 客户端 ID** 和 **API Gateway 端点**，您可以将其复制并粘贴到游戏中。
![\[场景部署状态更新\]](http://docs.aws.amazon.com/zh_cn/gameliftservers/latest/developerguide/images/unitypi_deploy_statedone.png)
1. 要更新游戏设置，请在 Unity 菜单上选择**转到客户端连接设置**。这会在 Unity 屏幕的右侧显示 **Inspector** 选项卡。
1. 取消选择**本地测试模式**。
1. 输入 **API Gateway 端点**和 **Coginito 客户端 ID**。选择与场景部署相同的 AWS 区域 选项。然后，您可以使用已部署的场景资源重建并运行游戏客户端。
### 删除场景创建的资源
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
要删除为该场景创建的资源，请删除相应的 CloudFormation 堆栈。
**删除由场景创建的资源**
1. 在 Unity **部署Amazon GameLift Servers**插件窗口中，选择**查看 AWS CloudFormation 控制台**以打开 CloudFormation 控制台。
1. 在 CloudFormation 主机中，选择 **Stacks**，然后选择包含部署期间指定的游戏名称的堆栈。
1. 要删除该堆栈，请选择**删除**。删除堆栈可能需要几分钟时间。 CloudFormation 删除场景使用的堆栈后，其状态将更改为`ROLLBACK_COMPLETE`。
## 在 Unity 中将游戏与 Amazon GameLift Servers 集成
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
完成以下任务，将您的 Unity 游戏与 Amazon GameLift Servers 集成：
+ [将 Amazon GameLift Servers 与 Unity 游戏服务器项目集成](integration-unity-server-sdk4.md)
+ [将 Amazon GameLift Servers 与 Unity 游戏客户端项目集成](integration-unity-client-sdk4.md)
下图显示了集成游戏的示例流程。在图中，带有游戏服务器的实例集部署到了 Amazon GameLift Servers。游戏客户端与游戏服务器通信，游戏服务器与 Amazon GameLift Servers 通信。
![\[将 Unity 与 Amazon GameLift Servers 集成的架构图。\]](http://docs.aws.amazon.com/zh_cn/gameliftservers/latest/developerguide/images/unity_diagram.png)
## 导入并运行示例游戏
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
适用于 Unity 的 Amazon GameLift Servers 插件包含一个示例游戏，可用于探索将游戏与 Amazon GameLift Servers 集成的基础知识。在本节中，您将构建游戏客户端和游戏服务器，然后使用 Amazon GameLift Servers Local 在本地进行测试。
### 先决条件
+ [设置 AWS 用户账户](setting-up-aws-login.md)
+ [安装并设置插件](#unity-plug-in-sdk4-install)
### 构建并运行示例游戏服务器
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
设置示例游戏的游戏服务器文件。
1. 在 Unity 中，在菜单上选择 **Amazon GameLift Servers**，然后选择**导入示例游戏**。
1. 在**导入示例游戏**窗口中，选择**导入**以导入游戏、其资产和依赖项。
1. 构建游戏服务器。在 Unity 中，在菜单上选择 **Amazon GameLift Servers**，然后选择**应用 Windows 示例服务器构建设置**或**应用 MacOS 示例服务器构建设置**。配置游戏服务器设置后，Unity 会重新编译资产。
1. 在 Unity 中，在菜单上选择**文件**，然后选择**构建**。选择**服务器构建**，选择**构建**，然后选择专门存放服务器文件的构建文件夹。
Unity 构建示例游戏服务器，将可执行文件和所需资产放在指定的构建文件夹中。
### 构建并运行示例游戏客户端
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
设置示例游戏的游戏客户端文件。
1. 在 Unity 中，在菜单上选择 **Amazon GameLift Servers**，然后选择**应用 Windows 示例客户端构建设置**或**应用 MacOS 示例客户端构建设置**。配置游戏客户端设置后，Unity 将重新编译资产。
1. 在 Unity 中，在菜单上选择**转到客户端设置**。这将在 Unity 屏幕的右侧显示 **Inspector** 选项卡。在 **Amazon GameLift Servers 客户端设置**选项卡中，选择**本地测试模式**。
1. 构建游戏客户端。在 Unity 中，在菜单上**文件**。确认未选中**服务器构建**，选择**构建**，然后选择专门存放客户端文件的构建文件夹。
Unity 构建示例游戏客户端，将可执行文件和所需资产放在指定的客户端构建文件夹中。
1. 您尚未构建游戏服务器和客户端。在接下来的步骤中，您将运行游戏并了解其如何与 Amazon GameLift Servers 互动。
### 在本地测试示例游戏
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
使用 Amazon GameLift Servers Local 运行导入的示例游戏。
1. 启动游戏服务器。在 Unity 的“适用于 Unity 的插件”选项卡中，选择**部署**选项卡。
1. 在**测试**窗格中，选择**打开本地测试 UI**。
1. 在**本地测试**窗口中，指定**游戏服务器 .exe 文件路径**。路径必须包含可执行文件名称。例如 `C:/MyGame/GameServer/MyGameServer.exe`。
1. 选择**部署并运行**。Unity 插件启动游戏服务器并打开Amazon GameLift Servers本地日志窗口。窗口包含日志消息，包括游戏服务器和 Amazon GameLift Servers Local 之间发送的消息。
1. 启动游戏客户端。使用示例游戏客户端找到构建位置并选择可执行文件。
1. 在 **Amazon GameLift Servers 示例游戏**中，提供电子邮件和密码，然后选择**登录**。电子邮件和密码未经过验证或使用。
1. 在 **Amazon GameLift Servers 示例游戏**中，选择**开始**。游戏客户端会寻找游戏会话。如果找不到会话，便会自行创建。然后，游戏客户端开始游戏会话。可以在日志中看到游戏活动。
#### 示例游戏服务器日志
```
...
2021-09-15T19:55:3495 PID:20728 Log :) GAMELIFT AWAKE
2021-09-15T19:55:3512 PID:20728 Log :) I AM SERVER
2021-09-15T19:55:3514 PID:20728 Log :) GAMELIFT StartServer at port 33430.
2021-09-15T19:55:3514 PID:20728 Log :) SDK VERSION: 4.0.2
2021-09-15T19:55:3556 PID:20728 Log :) SERVER IS IN A GAMELIFT FLEET
2021-09-15T19:55:3577 PID:20728 Log :) PROCESSREADY SUCCESS.
2021-09-15T19:55:3577 PID:20728 Log :) GAMELIFT HEALTH CHECK REQUESTED (HEALTHY)
...
2021-09-15T19:55:3634 PID:20728 Log :) GAMELOGIC AWAKE
2021-09-15T19:55:3635 PID:20728 Log :) GAMELOGIC START
2021-09-15T19:55:3636 PID:20728 Log :) LISTENING ON PORT 33430
2021-09-15T19:55:3636 PID:20728 Log SERVER: Frame: 0 HELLO WORLD!
...
2021-09-15T19:56:2464 PID:20728 Log :) GAMELIFT SESSION REQUESTED
2021-09-15T19:56:2468 PID:20728 Log :) GAME SESSION ACTIVATED
2021-09-15T19:56:3578 PID:20728 Log :) GAMELIFT HEALTH CHECK REQUESTED (HEALTHY)
2021-09-15T19:57:3584 PID:20728 Log :) GAMELIFT HEALTH CHECK REQUESTED (HEALTHY)
2021-09-15T19:58:0334 PID:20728 Log SERVER: Frame: 8695 Connection accepted: playerIdx 0 joined
2021-09-15T19:58:0335 PID:20728 Log SERVER: Frame: 8696 Connection accepted: playerIdx 1 joined
2021-09-15T19:58:0338 PID:20728 Log SERVER: Frame: 8697 Msg rcvd from playerIdx 0 Msg: CONNECT: server IP localhost
2021-09-15T19:58:0338 PID:20728 Log SERVER: Frame: 8697 Msg rcvd from player 0:CONNECT: server IP localhost
2021-09-15T19:58:0339 PID:20728 Log SERVER: Frame: 8697 CONNECT: player index 0
2021-09-15T19:58:0339 PID:20728 Log SERVER: Frame: 8697 Msg rcvd from playerIdx 1 Msg: CONNECT: server IP localhost
2021-09-15T19:58:0339 PID:20728 Log SERVER: Frame: 8697 Msg rcvd from player 1:CONNECT: server IP localhost
2021-09-15T19:58:0339 PID:20728 Log SERVER: Frame: 8697 CONNECT: player index 1
```
#### Amazon GameLift Servers Local 日志示例
```
12:55:26,000 INFO || - [SocketIOServer] main - Session store / pubsub factory used: MemoryStoreFactory (local session store only)
12:55:28,092 WARN || - [ServerBootstrap] main - Unknown channel option 'SO_LINGER' for channel '[id: 0xe23d0a14]'
12:55:28,101 INFO || - [SocketIOServer] nioEventLoopGroup-2-1 - SocketIO server started at port: 5757
12:55:28,101 INFO || - [SDKConnection] main - GameLift SDK server (communicates with your game server) has started on http://localhost:5757
12:55:28,120 INFO || - [SdkWebSocketServer] WebSocketSelector-20 - WebSocket Server started on address localhost/127.0.0.1:5759
12:55:28,166 INFO || - [StandAloneServer] main - GameLift Client server (listens for GameLift client APIs) has started on http://localhost:8080
12:55:28,179 INFO || - [StandAloneServer] main - GameLift server sdk http listener has started on http://localhost:5758
12:55:35,453 INFO || - [SdkWebSocketServer] WebSocketWorker-12 - onOpen socket: /?pID=20728&sdkVersion=4.0.2&sdkLanguage=CSharp and handshake /?pID=20728&sdkVersion=4.0.2&sdkLanguage=CSharp
12:55:35,551 INFO || - [HostProcessManager] WebSocketWorker-12 - client connected with pID 20728
12:55:35,718 INFO || - [GameLiftSdkHttpHandler] GameLiftSdkHttpHandler-thread-0 - GameLift API to use: ProcessReady for pId 20728
12:55:35,718 INFO || - [ProcessReadyHandler] GameLiftSdkHttpHandler-thread-0 - Received API call for processReady from 20728
12:55:35,738 INFO || - [ProcessReadyHandler] GameLiftSdkHttpHandler-thread-0 - onProcessReady data: port: 33430
12:55:35,739 INFO || - [HostProcessManager] GameLiftSdkHttpHandler-thread-0 - Registered new process with pId 20728
12:55:35,789 INFO || - [GameLiftSdkHttpHandler] GameLiftSdkHttpHandler-thread-0 - GameLift API to use: ReportHealth for pId 20728
12:55:35,790 INFO || - [ReportHealthHandler] GameLiftSdkHttpHandler-thread-0 - Received API call for ReportHealth from 20728
12:55:35,794 INFO || - [ReportHealthHandler] GameLiftSdkHttpHandler-thread-0 - ReportHealth data: healthStatus: true
12:56:24,098 INFO || - [GameLiftHttpHandler] Thread-12 - API to use: GameLift.DescribeGameSessions
12:56:24,119 INFO || - [DescribeGameSessionsDispatcher] Thread-12 - Received API call to describe game sessions with input: {"FleetId":"fleet-123"}
12:56:24,241 INFO || - [GameLiftHttpHandler] Thread-12 - API to use: GameLift.CreateGameSession
12:56:24,242 INFO || - [CreateGameSessionDispatcher] Thread-12 - Received API call to create game session with input: {"FleetId":"fleet-123","MaximumPlayerSessionCount":4}
12:56:24,265 INFO || - [HostProcessManager] Thread-12 - Reserved process: 20728 for gameSession: arn:aws:gamelift:local::gamesession/fleet-123/gsess-59f6cc44-4361-42f5-95b5-fdb5825c0f3d
12:56:24,266 INFO || - [WebSocketInvoker] Thread-12 - StartGameSessionRequest: gameSessionId=arn:aws:gamelift:local::gamesession/fleet-123/gsess-59f6cc44-4361-42f5-95b5-fdb5825c0f3d, fleetId=fleet-123, gameSessionName=null, maxPlayers=4, properties=[], ipAddress=127.0.0.1, port=33430, gameSessionData?=false, matchmakerData?=false, dnsName=localhost
12:56:24,564 INFO || - [CreateGameSessionDispatcher] Thread-12 - GameSession with id: arn:aws:gamelift:local::gamesession/fleet-123/gsess-59f6cc44-4361-42f5-95b5-fdb5825c0f3d created
12:56:24,585 INFO || - [GameLiftHttpHandler] Thread-12 - API to use: GameLift.DescribeGameSessions
12:56:24,585 INFO || - [DescribeGameSessionsDispatcher] Thread-12 - Received API call to describe game sessions with input: {"FleetId":"fleet-123"}
12:56:24,660 INFO || - [GameLiftSdkHttpHandler] GameLiftSdkHttpHandler-thread-0 - GameLift API to use: GameSessionActivate for pId 20728
12:56:24,661 INFO || - [GameSessionActivateHandler] GameLiftSdkHttpHandler-thread-0 - Received API call for GameSessionActivate from 20728
12:56:24,678 INFO || - [GameSessionActivateHandler] GameLiftSdkHttpHandler-thread-0 - GameSessionActivate data: gameSessionId: "arn:aws:gamelift:local::gamesession/fleet-123/gsess-59f6cc44-4361-42f5-95b5-fdb5825c0f3d"
```
### 关闭服务器进程
**注意**
本主题指的是适用于 Unity 的 Amazon GameLift Servers 插件版本 1.0.0（使用服务器 SDK 4.x 或更早版本）。
完成示例游戏后，在 Unity 中关闭服务器。
1. 在游戏客户端中，选择**退出**或关闭窗口以停止游戏客户端。
1. 在 Unity 中，在**本地测试**窗口中，选择**停止**或关闭游戏服务器窗口以停止服务器。