Unreal Engine 5 Dedicated Servers with AWS and GameLift

Tap into your most valuable resource in this course!

In order to package a dedicated server build, we need Unreal Engine from source.

Important things to keep in mind!

To build a dedicated server, we must compile Unreal Engine from source.

We discuss the prerequisites for integrating the GameLift Server SDK with our Unreal Engine project.

To package for a dedicated server, we must create a server Build Target. We learn about build targets and create one for server builds.

We lay out the game plan for integrating GameLift with our Unreal Engine project, and look at the prerequisites for compiling it. If you wish to skip these steps and download the necessary .dlls and GameLift plugin, download the OpenSSL binaries and Gamelift plugin .zip files in the resources.

We download Strawberry Perl, a prerequisite for OpenSSL. Don't worry, we won't be doing any Perl programming in this course!

We get NASM (Netwide Assembler), an assembler/disassembler for doing low-level operations - a prerequisite for OpenSSL

We build OpenSSL and get the coveted binaries we need to the GameLift SDK to implement its security measures.

We download the Amazon GameLift Server SDK

We compile the GameLift Server SDK and add its binaries to the GameLift plugin

We convert our project to use Rider as the IDE - it's now FREE for non-commercial use!

A quiz on Section 2

We create our AWS Account and take a look at the AWS Console Home

We learn how to manage our billing, and set up a billing alarm to send us notification if billing ever goes above a specified threshold. Everything we do in this course will be covered under the AWS Free Tier!

We learn the difference between an IAM User and Identity Center Users. We will be following best practices recommended by AWS and creating an Identity Center, Organization, and Identity Center User for daily use, so we don't use the Root User for daily tasks.

We set up Identity Center and make our Identity Center User.

We create a permission set and grant it to our Identity Center user to give it access to AWS.

A quiz on Section 3

We create a Game Mode and prepare it for code to connect to GameLift

We begin to add code to our Game Mode for harvesting data from command line arguments for the GameLift connection.

We implement the callback which GameLift will call on our Game Mode in response to the creation of a GameLift Game Session

We implement the callback which GameLift will call on our Game Mode in response to the termination of a GameLift process

We implement the callback for reporting health checks from the server to GameLift

We implement code to harvest the selected port from command line arguments or select the game process default if it isn't supplied

We call ProcessReady to initialize GameLift

We package the game, both for clients and the dedicated server

We add the OpenSSL binaries to our packaged build directory

A quiz on Section 4

We download the latest version of the AWS CLI (command-line interface)

We configure the CLI to retrieve our SSO credentials automatically

We learn how to create a gamelift location for our Anywhere Fleets

We create an Anywhere Fleet for hosting a dedicated server on our own compute resource (our PC)

We run the register-compute command to register our own compute resource with our Anywhere Fleet

We run get-compute-auth-token to get an authentication token for creating GameLift Game Sessions

We learn how we can test our dedicated server by connecting to it with a client build

We create a game session using the auth token we retrieved using get-compute-auth-token

We create a Player Session for our Game Session

A quiz on Section 5

We discuss what virtual machines are, why they are useful, and the benefits of hosting game servers on them rather than self-hosted hardware

We create an install batch file for virtual machines to execute upon startup, in order to install all required prerequisites to run our Unreal Engine dedicated server.

We upload our dedicated server build to GameLift so it can be run on a virtual machine

We create a GameLift-hosted fleet that can run EC2 instances with our dedicated server build

We launch our client build and connect to the cloud-hosted dedicated server, running on a virtual machine in an EC2 instance in our GameLift-hosted fleet.

We delete our fleet, ensuring that it will not use up our free EC2 hours while not in use.

A quiz on Section 6

We discuss how Lambdas are "serverless" and what it means for a function to be serverless

We create our first Lambda function

We discuss the anatomy of a Lambda function and all of its parts

We create a test event for our first Lambda function

We learn how to log information to the console and retrieve that information in Cloudwatch

We create a ListFleets Lambda function for listing all fleets

We discuss the try/catch block and how we can use it to control what happens in the event that our Lambda throws an error

Quiz on Section 7

We discuss our plan for setting up API Gateway to create API endpoints to trigger our lambdas via HTTP requests

We create a REST API in API Gateway

We create a module in our Unreal Engine project to encapsulate all of our dedicated server code

We create the Game Mode class for our dedicated servers module

We create a Test HUD for displaying widgets for sending and receiving HTTP requests

We create a List Fleets widget for our ListFleets API endpoint

We create an HTTP Request Manager class to handle sending HTTP requests, receiving HTTP responses, and parsing the data

We create a Data Asset to store the API endpoints for our APIs

We create an HTTP Request in our HTTP Request Manager class

We parse the HTTP Response to get its data

We parse the Metadata in our HTTP Response into a struct

We parse the payload for the ListFleets response

We parse errors and handle them when they occur

We create a ListFleets callback function for when we parse the response so we can display listed fleets to our HUD

We add Fleet Id widgets to our ListFleetsBox in the HUD

Quiz on Section 8

We set up the classes for our game Portal

We create callbacks for joining games

We create the code for describing fleet attributes

We loop over the fleets we found when describing fleet attributes

We call describe game sessions to find all game sessions running on our fleets

We create a game session if it does not already exist

We create an endpoint in our REST API for finding or creating a game session

We make the HTTP request for finding or creating a game session

We create the struct for holding information for the game session

We parse the HTTP response to store the data in our game session struct

Quiz on Section 9

We create a Lambda function for creating a player session

We create an endpoint to trigger our Create Player Session lambda

We handle the game session status to determine whether or not we can create a player session yet

We learn how to serialize content for our HTTP requests to pass data into the lambda's event object

We create the player session struct to hold player session data

We parse the HTTP response into a player session struct