Forem: Joseph B. Manley

Using AWS S3 to host HTML5 Godot projects

Joseph B. Manley — Fri, 19 Feb 2021 00:36:11 +0000

When working on a new project, you may want a simple website to share your game with friends and something that can, later on, support many thousands of active users. AWS offers a great storage solution called “Simple Storage Service” or “S3” that can do just that! For those unaware, AWS is Amazon’s cloud hosting platform. S3 is one of AWS’s core services that provides a simple key file store that users can access over the web or AWS’s easy-to-use API.

Below is a guide on how to get started with S3 with Godot HTML5. I also added a section on how to automate HTML5 builds with GitHub Actions.

Start by logging in to your AWS, if you need to create an AWS account, you can see the latest what to there that here. Once you are logged in to your AWS account, click the “Services” drop down and select “S3".

From here, you can create a new bucket. A bucket is a file store that.

Set a bucket name, region, and be sure that “Block all public access” is unchecked. If it’s checked you will not be able to access it from the internet in later steps.

Once you’ve finished creating your bucket, click on it’s name to open it up and go to the “Properties” tab.

Scroll all the way until you see the section titled “Static website hosting” and click “Edit”

Enable static website hosting and configure your paths. Later, I will export my game project as index.html , so I am going to use that for my index and error document.

After saving, if you scroll back to the “Static website hosting” portion of “Properties”, you should see your bucket’s new web address!

But, if you open it up right now, you will get a 403 error. This is because you need to give the pubic read access to the bucket.

To do this, go to “Permissions”. Then, scroll down to “Bucket policy” and click “Edit.”

For your policy, you can use this template where [YOUR-BUCKET-NAME-HERE] is the name of your bucket.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "PublicReadGetObject",
            "Effect": "Allow",
            "Principal": "*",
            "Action": [
                "s3:GetObject"
            ],
            "Resource": [
                "arn:aws:s3:::[YOUR-BUCKET-NAME-HERE]/*"
            ]
        }
    ]
}

For me, it looks something like this:

After saving, if you refresh your web endpoint and tada, you have a static website! All that’s left is to export and upload your project!

Manually Exporting and Uploading

Open up your Godot project and export your project for HTML5. Be sure, your export name is the same as your index document name in your S3 configuration. If you have any issues see the Godot documentation.

After exporting, here is my directory:

.
├── favicon.png
├── favicon.png.import
├── index.html
├── index.js
├── index.pck
├── index.png
├── index.png.import
└── index.wasm

Now back in the S3 console, you need to go to “Objects” then click “Upload”

Then select “Add Files” and select all the files in your build directory.

Here is what I have:

After you click “Upload”, you can refresh your site and there is your game!

Automating with GitHub Actions

First, your game project code is required to be hosted on GitHub. If you don’t know how to do that, here is a guide on getting started with GitHub: https://guides.github.com/activities/hello-world/

Create a new file in your repo .github/workflows/build.yaml from this snippet (https://gist.github.com/josephbmanley/36c2d47cc94e7a83a430285f301963e5) and update the AWS_S3_BUCKET and AWS_REGION fields.

This file represents your workflow. Your workflow gives a list of steps for GitHub to do when there is a new event. In this case, on push (upload to GitHub), it will download your project, build it with the latest version of Godot, and upload the result to S3.

Though, if you notice it has secrets.AWS_ACCESS_KEY_ID and secrets.AWS_SECRET_ACCESS_KEY . Both of these, you need to feed to GitHub, so it have access to your S3 bucket.

To do this, go to the AWS console, then “Services”, and select “IAM”.

Then go to “Users” and “Add user”

Use a user name of your choice and make sure that “Programmatic access” is checked.

On the next page, click the “Attach existing policies directly” tab and search for S3. Then, select the “AmazonS3FullAccess” policy. If you are more familiar with AWS and IAM, I would instead suggest creating your own policy for minimal access.

Now, click through the next few prompts until your user is created. Here you’ll see your new access key ID and secret access key. Save those values because these are the values that will be put into GitHub.

In your GitHub repo, go to “Settings”, “Secrets”, and then “New repository secret”

In here put AWS_ACCESS_KEY_ID with the value being the access key id you saved earlier. Then, repeat the process for AWS_SECRET_ACCESS_KEY with your secret access key.

Now, the next time you push to GitHub. Your S3 bucket should be updated and your game accessible!

Where to go from here?

Congratulations, you now have a simple website that you can use to share your project anywhere! If you want to improve your website, I suggest looking into to use CloudFront to enable caching and HTTPS for your website: https://aws.amazon.com/premiumsupport/knowledge-center/cloudfront-https-requests-s3/

Creating a AWS Lambda function with Haxe

Joseph B. Manley — Tue, 16 Feb 2021 23:38:13 +0000

Over the weekend, I had some fun and experimented with Haxe. For those unaware, Haxe is a typed multi-platform high-level programming language mostly used for game development, such as the indie hit Deadcells. While exporting to JavaScript, I thought, “Hey, would this work with Lambda?” Sure, enough, it can.

Image Source: Haxe Foundation

Is it very practical? I’m not so sure. Haxe isn’t as popular as Python or JavaScript, therefore not having as much third-party support, and Haxe isn’t run directly but rather as an exported language of your choice. But if you’re a Haxe shop or want a strongly typed language that can run well and easily on AWS, it’s worth a quick look.

Bellow, I put together a quick guide on how to get started with Haxe on Lambda.

Building a simple Haxe Lambda function

First you need to setup your Haxe project. For this guide, I am going to use Handler as my main class and will export to JavaScript to export/handler.js

Here is my structure:

├── compile.hxml
├── export // Note: Directory won't exist until compile
│ └── handler.js
└── src
    └── Handler.hx

Here is my compile.hxml :

-cp src
--js export/handler.js
--main Handler

Now let’s jump into the Haxe code. Here is the start of my src/Handler.hx :

class Handler {
    static function main() {}
}

As a note here, while Handler.main is not executed by the Lambda function, it is still required to property export your Haxe project.

It’s actually really simple, first we just have to expose the Handler class, you that it can be accessed by JavaScript files by adding @:expose

@:expose
class Handler {
    static function main() {}
}

Then we can add our lambda handler function:

class Handler {
    static function main() {}
    static function handler() : String {
        return "Hello from Haxe!"
    }
}

Now go and compile your code, to do so call haxe compile.hxml from your project directory.

Now the big secret to getting your function called is by passing your function through to the lambda function. This can be achieved importing your exported Javascript and calling the function from an async method. This file will become the entrypoint for your Lambda function. In my case it’s export/index.js

const handler = require("handler");

exports.handler = async function(event, context, callback) {
    return handler.Handler.handler(event,context,callback);
}

Now, if we zip up our export directory and upload it to our lambda function…

Using Reading inputs

If you noticed in the previous part, we pass the event, context, and callback objects all to our function in index.js . This is because we can actually reference those objects as an AnonType and referencing the properties we would like to access. Here’s an example using the event object:

@:expose
class Handler {
    static function main() {}

    static function handler(event : {source : String}) : String {

        // Run your Haxe code
        var eventSource: String = event.source;

        // Return response
        return 'Hello to $eventSource from Haxe!';
    }
}

Now with the context object:

@:expose
class Handler {
    static function main() {}

    static function handler(event : {source : String}, context : {functionName : String}) : String {

        // Run your Haxe code
        var eventSource : String = event.source;
        var lambdaName : String = context.functionName;

        // Return response
        return 'Hello to $eventSource from $lambdaName!';
    }
}

How TetraForce runs Godot on AWS

Joseph B. Manley — Fri, 06 Nov 2020 07:27:40 +0000

TetraForce is an open-source multiplayer action-adventure RPG inspired by the popular Zelda game, Link's Awakening. It uses Godot’s built-in UDP networking library and scripting language for most of the game’s logic.

The main developers managing the project are fornclake and TheRetroDragon. Back in July, I got in contact with them to discuss putting TetraForce into the cloud! Within a week, TetraForce was running on AWS. Since then, there have been many gradual improvements to get the project where it is today.

For a summary of this project, the Amazon Elastic Container Service cluster manages and runs TetraForce’s containers using a serverless API. Initially, our cluster was hosted in an auto-scaling group of EC2 instances (Virtual Machines). Later, it was moved to AWS Fargate (Serverless Container Platform) to simplify scaling and reduce costs during periods of low utilization.

There is a Serverless REST API using Lambda for creating and joining rooms, which sends and sets server information, such as name and ECS task ID, in a DynamoDB table. When a server closes, an additional lambda removes it from the DynamoDB table.

Now let’s jump into some of the details.

Dockerization

Godot being lightweight, is easy to Dockerize. For the TetraForce Docker image, it just installs dependencies, the Godot server runtime, and the TetraForce’s pck file. It can easily be extended to add additional pck files in the future for mods or expansions.

As of when this post was written, this is our working Dockerfile:

FROM centos:centos8

RUN yum install -y wget unzip libXcursor openssl openssl-libs libXinerama libXrandr-devel libXi alsa-lib pulseaudio-libs mesa-libGL

ENV GODOT_VERSION "3.2.2"

# Install Godot Server
RUN wget -q https://downloads.tuxfamily.org/godotengine/${GODOT_VERSION}/Godot_v${GODOT_VERSION}-stable_linux_headless.64.zip \
    && unzip Godot_v${GODOT_VERSION}-stable_linux_headless.64.zip \
    && mv Godot_v${GODOT_VERSION}-stable_linux_headless.64 /usr/local/bin/godot \
    && chmod +x /usr/local/bin/godot

# Create Runtime User
RUN useradd -d /tetra tetra


# Add pck file
ADD build/TetraForce.pck /tetra/TetraForce.pck

CMD /usr/local/bin/godot --main-pack /tetra/TetraForce.pck --empty-server-timeout=300

The CMD for the image is to run the Godot server runtime using the TetraForce pck file. You can notice in the run command we also pass a --empty-server-timeout=300; this is for our containers to close servers that have no active players automatically.

Server Management

Each game room runs as a task in ECS. Amazon assigns those tasks a public IP. The client receives those IPs by interacting with TetraForce’s API.

The REST API

The client can get room information and create new rooms by making HTTPS requests to the REST API. The REST API uses API Gateway to route requests to a Lambda functions.

The /create_server endpoint takes in an optional parameter of a name. If it does not have a name, it will randomly generate one. From there, it will spin up a new ECS task tagged with the room’s name and add a new entry into the DynamoDB table. The Lambda function will return whether it was a success and the name of the room created.

The /get_servers endpoint takes in an optional parameter of a room name and page. If it’s passed a name, it will only do a lookup for the given room. Otherwise, it will return a list of room information. The room information includes the room name, public IP, and port. It’s also modular to all for additional values in the future, such as version.

CloudWatch Events

Server cleanup is managed by an additional Lambda function that is triggered by a CloudWatch Event Rule:

{
  "source": ["aws.ecs"],
  "detail-type": [ "ECS Task State Change" ]
}

This event will trigger the Lambda anytime an ECS Task in the cluster enters a new state. That leaves the responsibility of verifying the task’s state and then removing the room from the DynamoDB table if it’s no longer running to the Lambda function.

Client Integration

Using Godot’s HTTPRequest Node, the client can hit the REST API hosted on AWS to request server information or create a new lobby.

export(String) var api_endpoint = "api.tetraforce.io"

var _http_client : HTTPRequest# Asynchronous coroutine.
# Requests API for data from a specific server
# Returns: {"message": [MESSAGE], "data" : [DATA] }
func get_server(lobby : String) -> Dictionary:
    _http_client.request("https://" + api_endpoint + "/get_servers?server=" + str(lobby), [], true, HTTPClient.METHOD_GET)
    var result = yield(_http_client, "request_completed")
    if len(result) > 3 and result[1] == 200:
        var json : JSONParseResult = JSON.parse(result[3].get_string_from_utf8())
        if json.error:
            return _build_error_message(json.error_string)
        return json.result

    return _build_error_message("Request failed!")

After that, the client will parse the returned JSON object into a dictionary. That dictionary will include the public server IP and Port, which is passed into the connection method when the player attempts to connect to the game server.

What’s next?

The team is currently moving forward towards building a full demo of TetraForce within the next few months. The demo will include a handful of zones, a dungeon, and an eventual boss battle.

The team is looking to include skins in their game as Patreon rewards on the infrastructure side, so a user identity system is here on the horizon.

If you have any questions about anything, feel free to reach out to me on Twitter.

Forem: Joseph B. Manley

Using AWS S3 to host HTML5 Godot projects

Manually Exporting and Uploading

Automating with GitHub Actions

Where to go from here?

Related Links

Creating a AWS Lambda function with Haxe

Building a simple Haxe Lambda function

Using Reading inputs

Related Links

How TetraForce runs Godot on AWS

Dockerization

Server Management

The REST API

CloudWatch Events

Client Integration

What’s next?

Related Links