DEV Community: Manuel Figueroa

Setting up a Palworld server in AWS

Manuel Figueroa — Mon, 12 Feb 2024 13:00:00 +0000

Image by vectorjuice on Freepik

A couple of weeks ago, a game called Palworld released and took the gaming world by storm. My brother and I wanted to play it co-op, but due to issues with the multiplayer server, we couldn't. Luckily, we found that Palworld has a dedicated server that we can host it anywhere we want. I took this opportunity to try and host it myself using AWS.

Setting up the EC2 instance

The first step is to spin up a virtual server using Amazon Elastic Compute Cloud (EC2), amazon's on demand virtual servers. For the image, I decide on Ubuntu since it was easier to set up the required dependencies for the Palworld server.

According to the recommended server specs we need at least 16GB of RAM, for this, I opt for the t3.xlarge instance and for the Elastic Block Storage (EBS) I put 30GB of storage.

Before moving on to the installation of SteamCMD and the Palworld dedicated server, I decided to create a specific Security Group and an Elastic IP address for this EC2 instance.

Security Groups

A security group controls the traffic allowed to reach and leave the resources that it is assigned to. For my instance, I created a new security group called Palworld Server Security Group and then edit the inbound rules for this group. I enabled SSH to accept connections from my local IP address and allowed UDP port 8211 to accept any IPv4 requests. This will let anyone with the server IP address and port connect to the Palworld server using the in game server browser.

Elastic IP

Before February 1st, 2024, Elastic IP Addresses assigned to an instance were free, but now, they charge US$0.005/hour, you can read more about it here.

IP addresses in the cloud are dynamic by nature; every time I stop an EC2 instance and then start it up again, it gets a new IP address. Due to this, I opted to use an Elastic IP address.

Elastic IP is a static IPv4 address designed for dynamic cloud computing. My main motivation to use an Elastic IP was so that I didn't have to share the server IP address every time my brother or cousins wanted to play.

That's all the setup as far as AWS console goes, now we will SSH into the EC2 instance to install everything we need to run the Palworld dedicated server.

Installing SteamCMD and Palworld server

SteamCMD

SteamCMD is a Steam client CLI tool for installing and updating dedicated servers, to install it on ubuntu as per the documentation we run:

sudo add-apt-repository multiverse; sudo dpkg --add-architecture i386; sudo apt update
sudo apt install steamcmd

After the setup is complete, we can type in the following command:

steamcmd

If everything works, you should be inside a SteamCMD prompt

$ steamcmd
tid(931) burning pthread_key_t == 0 so we never use it
Redirecting stderr to '/home/ubuntu/Steam/logs/stderr.txt'
Logging directory: '/home/ubuntu/Steam/logs'
[  0%] Checking for available updates...
[----] Verifying installation...
Steam Console Client (c) Valve Corporation - version 1705108307
-- type 'quit' to exit --
Loading Steam API...dlmopen steamservice.so failed: steamservice.so: cannot open shared object file: No such file or directory
OK

Steam>

That's all for the SteamCMD setup, now we move on to install and configure the Palworld server.

Palworld dedicated server

Our first step is to download and install the dedicated server, to do this we run the following command:

steamcmd +login anonymous +app_update 2394010 validate +quit

+login anonymous let us log in into steam as anonymous user.
+app_update <app_id> installs or updates the installation of the given app_id.
validate checks the server files to make sure they match with SteamCMD files.
+quit logs off from the Steam servers.

After the download is complete, we go to the download directory, which, in my case, it was in my user's home directory.

cd ~/Steam/steamapps/common/PalServer

Now we simply run:

./PalServer.sh

On the first run, it will throw the following error:

.steam/sdk64/steamclient.so: cannot open shared object file: No such file or directory

As per the documentation, we can fix this with the following commands:

mkdir -p ~/.steam/sdk64/
steamcmd +login anonymous +app_update 1007 +quit
cp ~/Steam/steamapps/common/Steamworks\ SDK\ Redist/linux64/steamclient.so ~/.steam/sdk64/

It creates a folder called sdk64.
It installs the Steamworks SDK Redistributable.
Copy the file steamclient.so to ~/.steam/sdk64/.

With that out of the way, we can run this command again:

./PalServer.sh

If we get the following line after running the previous command, the server is up and running successfully:

[S_API] SteamAPI_Init(): Loaded '/home/ubuntu/.steam/sdk64/steamclient.so' OK.  (First tried local 'steamclient.so')

We are almost done. The last thing we need to do is to change some of the server settings.

Configuring the Palworld server

Running the server for the first time will generate a configuration file in the following location:

steamapps/common/PalServer/Pal/Saved/Config/LinuxServer/PalWorldSettings.ini

As per the documentation found here, we need to copy the default settings found in steamapps/common/PalServer/DefaultPalWorldSettings.ini.

There are many server parameters we can edit, but for now we only need to change the following:

ServerName: We type in the name of our saver, in our case, we called it Eternia
ServerPassword: We can set a server password here.
PublicIP: We need to type in the Elastic IP address we set up earlier.
PublicPort: We can specify a port number here, the default is 8211.

With those final steps, we are all set to begin our journey into Palworld.

Nice!👍🏻

Closing thoughts

Setting up a game dedicated server with AWS was a really fun experience, from the proper setup of the EC2 instance, to the correct setup of the security group and the allocation of the Elastic IP while also installing and configuring all the dependencies needed to host the Palworld server.

With this little project under my belt, I'm looking forward to set up all kinds of dedicated servers, from Minecraft to Enshrouded and anything else that comes in between.

Hope to see you again as I continue my journey towards the cloud.

Hugo website CMS

Manuel Figueroa — Thu, 25 Jun 2020 11:29:49 +0000

Introduction

In my previous post, I successfully deployed a Hugo static site through Netlify, you can read all about it here. I managed to create the post with ease using Markdown, but, despite the relative simplicity, it got me thinking. Is there some kind of Content Management System (CMS) for static sites? To my surprise, YES there is, but before we get all excited and dive in into this, lets put up some context of what a CMS is, and why it could help you with your own blogs.

What is a Content Management System?

A Content Management System (CMS for short) is a software application that allows users to build and manage a website without having to code it from scratch, one of the big ones in the CMS space is Wordpress, you can easily create a websites and also content for it. The CMS are usually a little to no code solution for people who wants to have a website without dealing with the complexities of web technologies like HTML/CSS, JavaScript, PHP etc.

In this case, I’m looking for a different way of managing my content, don’t get me wrong, I like how I set my blog site up, and writing in Markdown is really cool, but if I can find a way to enhance it, I’m all in for it. The Hugo website has some recommendations for CMS, you can check out in the documentation.

After glancing over the different suggestions, the one that caught my eye was Netlify CMS, it is funny because I am starting to feel like a Netlify fanboy, but hey, they make interesting stuff.

Netlify CMS

Netlify CMS is an open source content management system for your Git workflow that enables you to provide editors with a friendly UI and intuitive workflows. You can use it with any static site generator to create faster, more flexible web projects.

Sounds fun, for this experiment I’ll be implementing it on an existing Hugo site.
If you want to learn more about Netlify CMS you can check it out here.

Adding the CMS on an existing Hugo site

For the purpose of this post, I’ll use the Hugo quickstart site, you should have something like this.

Now, let’s deploy our site through Netlify, I went with it due to its ease of use and the fact that I deployed my blog through it. You can use Netlify CMS with other hosting solutions, but I’ll be using Netlify since I already know the very basics of it. If you want to know how I did it for my blog, check out this post, or you can always check the documentation here.

With the site deployed, It’s time to start implementing Netlify CMS.

I followed the instructions from the documentation, and I have to say, it was really easy to implement, the documentation was easy to follow, and I had the CMS on production very quickly. Keep in mind that I did host the site on Netlify which made it easier, so you millage may vary depending on the host you choose.

Here is the admin panel working on the website

Create Post page

I also tested the Editorial Workflow which is available on GitHub hosted repositories and it is on beta for GitLab and Bitbucket. This lets me save drafts, review changes and publish when the article is ready.

Now, I will hit publish, this will create a new commit on our master branch, that Netlify will take and deploy.

A great success!!

Closing thoughts

I enjoyed this experiment a lot, a CMS can certainly help you if you need some visual aid while editing content, or you simply don’t want to deal with Markdown directly. Netlify CMS was a surprise for me, because I thought it would be way harder to implement, but thankfully it wasn’t, and I will have on the back of my head if I ever need to make another website with a static site generator and need a CMS. Maybe in the future, I’ll try another CMS, or another static site generator, but for now, I’m really happy with my current setup, Hugo, Markdown, VS Code and Netlify.

Hope to see you around for my next post.

The Road to the First Blog

Manuel Figueroa — Wed, 17 Jun 2020 22:26:50 +0000

Introduction

After doing some pet projects here and there, learning the basics of git and GitHub, I started to think what I could do as a little pet project to publish on the web, no matter how small.

A friend of mine suggested I should try to create a blog using a static site generator like Jekyll, Hexo, Hugo, Gatsby etc. Then it occurred to me that I should write a blog documenting my learning process.

With that in mind, let us get started.

In the past, I’ve made a couple of WordPress websites and for this project I was leaning towards that, but it felt like overkill for a pet project, and I also wanted to experiment with something that I haven’t touch before.
I wanted a simple site generator that was not dependent of a JavaScript library like React, or a framework like Angular or Vue, my search led me to Hugo.

Hugo

“Hugo is a general-purpose website framework. Technically speaking, Hugo is a static site generator. Unlike systems that dynamically build a page with each visitor request, Hugo builds pages when you create or update your content. Since websites are viewed far more often than they are edited, Hugo is designed to provide an optimal viewing experience for your website’s end users and an ideal writing experience for website authors”.

Features

Extremely fast build times
Renders changes on the fly with LiveReload as you develop
Powerful theming
Host your site anywhere
Straightforward organization for your projects, including website sections
Customizable URLs
Support for configurable taxonomies, including categories and tags
Automatic table of contents generation
Dynamic menu creation
Pretty URLs support
Permalink pattern support

For the full list of features, click here.

With that in mind, and my curiosity picked, I installed Hugo following these instructions, after that, I looked up a theme, and choose one called hyde-hyde, then a couple of minutes later and some tinkering, I have this:

GREAT! I have something working on my machine, I will add some more customization like a profile picture, a little description, social links etc. this looks really promising. Before editing some of the CSS, I decided that I want to deploy the site to the web, my choice for this was Netlify.

Deployment

Before Netlify can do anything, I need to create a Git repository on a Git hosting solution like GitHub. How Git and GitHub works is out of the scope of this post, but if you want to know more about Git you can click the following link, and for GitHub you can go here. With the project now on GitHub, we can go to Netlify and start the deployment process.

Netlify is a web host that offers a simple way to deploy sites on the web with the always loved git workflow. I registered using my GitHub account, in the Netlify console I clicked “new site from git”, I choose GitHub, but it also supports GitLab and Bitbucket, configured some basic deployment settings and hit publish, a couple of minutes later, my very basic site was deployed successfully on Netlify, with Continuous Delivery(CD) already set up, this means that every time I push a change to my master branch on GitHub, Netlify will deploy automatically the changes to the website, this is awesome for a blogging website. For more info on how to deploy on Netlify you can go to the Netlify documentation.

Now, let’s create our first blog post, I will run the following command on my terminal:

    hugo new web/0001-test/index.md

We will have the following structure inside our content folder

    .
    └── content
        └── web
        |    └── 0001-test
        |           └── index.md

index.md is the file we will work on. By default, Hugo comes with a default.md in the archetypes folder, this will be use when you create a new file using the command we used previously. Since I did setup some archetype for my content, here is how my index.md looks like.

    ---
    title: "0001 Test"
    slug: "0001 Test"
    date: 2020-06-10T14:20:53-04:00
    tags : [
        "Web"
    ]
    categories : [
        "Web Development"
    ]
    layout: post
    type:  "web"
    highlight: true
    draft: true
    ---

I will type some text and just below the end of the front matter

    # Hello World!!!

Now, the moment of truth

Homepage View

Post View

Note: if you check on top of your index.md, you will notice the following

draft: true

this means that the content will not be displayed on the website if you deploy it right now. To change this, just replace

draft: true

with

draft: false

Organization

Before we wrap up, let’s talk about Hugo content organization, Hugo supports content nested at any level, however the top levels (i.e. content/<DIRECTORIES>) are special in Hugo and are considered the content type used to determine layouts etc. Knowing this, I did the following structure:

    .
    └── content
        └── web
        |    └── <PostDirectory>
        |           └── index.md
        └── mobile
        |    └── ...
        |
        └── gamedev
        |    └── ...
        | ...

Why I did it this way?

First of all, I wanted to leverage the power of Hugo archetypes, second, since I’ll be touching different topics about programming, I split the content in broad categories, like web development, mobile development, game development etc. this helps me with my file organization while also giving me room to grow.

Closing thoughts

This journey has been very fun, I created a little blog site in a couple of days, deployed it through Netlify, while I also wrote my first blog post ever documenting my steps and a bit of my struggles, learned a lot about static site generators, deployment experience through Netlify, Markdown file editing, and a bit of wizardry with the terminal, all and all, a cool experience.

Hope to see you around for my next post.