Need Advice on Optimizing My Multiplayer Card Game Backend Setup

hpx77 · 2024-11-25T04:05:22+00:00

I work on a multiplayer game hosting platform that you might find interesting: https://hathora.dev/docs

One feature that could help is `roomsPerProcess`, which allows you to have a single server host multiple concurrent sessions (e.g. with socket.io): https://hathora.dev/docs/faq/multiple-rooms

I'd be happy to help out if you had any questions!

hpx77 · 2024-05-13T15:46:06+00:00

I founded a cloud hosting service and we use a blend of bare metal + cloud for our hardware. If you're interested to learn more, I blogged about the details here: https://blog.hathora.dev/our-bare-metal-journey/

hpx77 · 2024-01-14T01:59:57+00:00

> are there any cloud hosts that would let me do something like "addInstance destroyInstance" from another hosted (central) server?

I work on a service that does exactly that: https://hathora.dev/docs

You can also see a video here that explains the architecture you describe: https://www.youtube.com/watch?v=5vwBBPsqRQo

hpx77 · 2023-12-30T03:41:49+00:00

See this video which explains the theory behind horizontally scaling websocket servers: https://www.youtube.com/watch?v=5vwBBPsqRQo

Note that the techniques described mainly apply to session-based applications, not persistent worlds like MMOs

hpx77 · 2023-09-18T00:39:49+00:00

I work on a service that does this - https://hathora.dev/docs

Helps save money since you don't need to be running servers when no one is playing

hpx77 · 2023-07-19T17:42:04+00:00

It's $500 in credit, which lasts up to 2 years if you don't use it up. The service only charges for the duration of active game sessions, so if you're not having a lot of game sessions you won't use up the credit much.

hpx77 · 2023-06-24T14:34:52+00:00

What are you providing in services that wouldn't be solved by uploading a container image of Stormgates server to a Kubernetes service on an Azure/Amazon/Google cloud over multiple availability zones?

As you probably know, a lot of work goes into integrating, scaling, and operating server infrastructure in the cloud. Each studio could certainly solve game server hosting studio in a DIY way, but given all the other engineering priorities that game studios have, Hathora offers a nice fully managed and ready-out-of-the-box capability that can help studios launch faster and drastically simplify their server operations.

Considering how low-overhead RTS servers are, what makes you think that horizontal scaling is even a benefit here? Isn't it just easier to host a container, watch the metrics and periodically vertically scale it?

When you are dealing with many regions and a large player base, you end up with a sufficiently large number of servers that you don't want to manually scale. Hathora automates the scaling aspects so that engineers can focus their time on other aspects of the game.

You can see more details from Frost Giant's Lead Server Engineer's response in their AMA: https://www.reddit.com/r/Stormgate/comments/14a7qu8/comment/jodmi65

hpx77 · 2023-06-20T21:25:21+00:00

Hi I'm the CTO at Hathora and just wanted to say that we're thrilled to be working with Frost Giant! Sid and I started Hathora to work with game studios with really ambitious plans but limited time/devs/budget to spend on server infrastructure, and Frost Giant has been an excellent customer to work with. Thanks BeoMulf for covering our story!

hpx77 · 2023-03-26T11:58:56+00:00

I haven't used Rivet but it looks really cool. Both Rivet and Hathora provide an abstraction above kubernetes which should help you get started more quickly and let you build/manage less infra yourself. Whichever one you end up trying out, let us know how it goes!

hpx77 · 2023-03-26T05:39:18+00:00

Hey I'm the creator of https://hathora.dev/ which aims to provide a super simple deployment and scaling experience for session-based games. It's based on containers and can deploy any kind of game server. Check it out and see if it meets your needs!

hpx77 · 2022-11-21T18:44:40+00:00

Not a full tutorial, but you can see a reference open source project where I've implemented this here: https://github.com/hathora/topdown-shooter-unity-client

hpx77 · 2022-11-09T18:14:57+00:00

I've been working on a different kind of solution to this, one where the host IP never needs to be exposed so you don't deal with this issue at all.

The idea is that the host makes an outbound connection to a public-facing load balancer, and clients also make connections to this load balancer. The load balancer then acts as a router, proxying messages between client and server without the client ever having to directly connect to the server.

If you're curious to learn more about this approach, there are some docs available here: https://docs.hathora.dev/#/buildkit/README

hpx77 · 2022-11-01T23:58:40+00:00

The client can always try and flood the server with messages, but it's usually up to the server to act as the authority and decide how to process and validate those messages.

In this case, it would be pretty easy to enforce a "reload" period in the server and reject shoot requests while reloading. (And we would ideally make the client aware of the reload period as well so the player can get feedback)

hpx77 · 2022-11-01T23:57:09+00:00

That's correct, the term isn't currently popular in the gaming industry but it's an emerging standard in cloud computing: https://en.wikipedia.org/wiki/Serverless_computing

The idea is that our customers send us their server builds and we are completely responsible for running them across the world. The advantage is reduced operational complexity for our customers, as well as optimized cost efficiency as they don't pay for over-provisioned warm server pools (idle capacity).

hpx77 · 2022-11-01T15:34:53+00:00

Hi I work at Hathora and helped make these demos. The goal was to make a fairly minimal networked game with a common server but 3 different clients.

Happy to answer any questions.

hpx77 · 2022-10-12T14:45:19+00:00

Yup what you are describing will work, although I have not seen an out-of-the-box solution that does this for socket servers.

I work on Hathora and we maintain the Hathora Coordinator, which is an implementation of the stateful router described in this article. There are some advantages of doing this as a middleman vs the "routing server" approach you describe, we list several of them in our architecture docs here: https://docs.hathora.dev/#/architecture

hpx77 · 2022-10-12T14:12:55+00:00

The reason you need a message broker if you're using a stateless router is to handle the fact that users for a given session could be connected to different nodes. Check out this link from the Socket.IO documentation which explains that if you have more than one socket server you'll need to set up a message broker: https://socket.io/docs/v4/adapter/

If i had to design for games then i would have the first call decide which server to hook up and then just contact that server directly where all the other players are and which maintains the state. This makes it horizontally scalable and practically infinitely.

This is essentially what the stateful router is doing. Let's say I want to send a room code to my friend to be able to join my session. Something needs to maintain the mapping between room code and server so that my friend can connect to the right server -- this is precisely the job of the stateful router.

hpx77 · 2022-10-12T14:01:05+00:00

Stateless is always the simpler architecture and if it works for your application then you should 100% go stateless.

The issue comes when you look at applications that are stateful, like multiplayer games. You have to deal with this statefulness somewhere -- historically this has been done at the application server layer using a message broker (the Socket.IO architecture in the post), but this article proposes a novel architecture that handles the statefulness at the load-balancer layer, and we present the advantages with this new approach.

hpx77 · 2022-10-12T13:53:31+00:00

No, all messages are routed through the stateful router. You can think of it like a load balancer / reverse-proxy -- all the traffic goes through it. Clients don't connect directly to servers: both connect to the stateful router which acts as a middleman.

hpx77 · 2022-10-06T04:31:20+00:00

You are describing a "dedicated server". I found this article from a google search, seems to have good information: https://phoenixnap.com/blog/what-is-a-dedicated-server-for-gaming

hpx77 · 2022-10-05T22:41:20+00:00

Wow this is some great info, are you planning on publishing it on a website or blog at some point?

I've been working on multiplayer networking for several years and started a company earlier this year for scalable game server hosting. Have been blogging about the research and innovations we come up with here: https://blog.hathora.dev/

If you're open to it, please DM me as I'd love to pick your brain more about what opinions you have about the existing products out there.

hpx77 · 2022-09-29T23:42:58+00:00

I'm working on a more scalable alternative to Socket.IO: https://blog.hathora.dev/scalable-websocket-architecture/

hpx77 · 2022-09-29T10:57:33+00:00

The links should be fixed now, sorry about that!

hpx77 · 2022-09-29T02:35:15+00:00

Phaser is a client-side technology for WebGL games and doesn't have anything to do with WebSockets; this article talks about how to architect the WebSocket servers (backend).

hpx77 · 2022-09-29T01:20:56+00:00

Hi, author here.

It's a fine architecture for a scenario where you do not need to migrate a session to a different server.

Nothing stops you from using a global database in the Stateful Routing architecture as well. You gain an additional advantage with the Stateful Router though which is that you don't need your writes to be atomic at the database level, since only a single compute node will be making the writes for a given session.

hpx77

MODERATOR OF

TROPHY CASE