✨ Community Interest: Service for deploying/scaling game servers?

[reececomo]

Gamedev is already hard. Infra + devops is hard too, especially so for browser games.

Geckos.io makes UDP networking easy, and given many browser-based games would have similar hardware/hosting requirements, I wonder how much interest the community might have in a service that deployed your game server fleet for you?

💥 Example challenges with WebRTC infra / devops

• ⌚ Teams have to configure and manage their own hardware, auto-scaling, task/service defintions, containers, CI/CD, fleet management API/lamdas, etc.
  • High startup cost! Most game developers have limited (or zero) experience with most of these tasks.
  • Expensive. Even the cheapest AWS hardware will be overkill for most geckos.io games*.
  • Time-consuming, tedious, error-prone & repetitive, even with tools like terraform.
• 💤 Slow cold boots for game servers (autoscaling + dns propogation)
  • Browsers require HTTPS for geckos.io signaling server.
  • Auto-scaling means dynamic subdomains. DNS propogation adds to the already slow cold boot times.
  • Could a reverse-proxy get around this? Not sure what impact that would have on WebRTC ICE.
• 🌎 Requires warm game servers.
  • ~$16 USD/mo per hardware server per region, on cheapest ECS hardware (+ public IP address). Assuming warm 24 hours per day.
• 🟢 Canary deploys.
  • Allow updates to propogate without killing in-progress games.

This isn't even mentioning advanced production requirements like DDOS protection, etc.

_{*Generally speaking. Depends on the game - i.e. memory/bandwidth requirements could be more significant.}

What would a service look like?

1. You upload server code (or container image)
2. Choose regions / auto-scaling rules & limits
3. Use API to get server addresses

Something halfway between Fly.io (hosting) and Agones.dev (gameserver fleet management) - for webrtc browser games.

e.g. in your server

Game servers would register themselves with the third party service:

import fleetManager from '@example-wrtc-fleet-service/server'

// ✨ Register your game server as available, and start the heartbeat.
fleetManager.register({
  version: myGameWorld.GAME_VERSION,
  address: { host, port },
  region: 'north-america-east',
  playerCapacity: 10
})

// ✨ Tell fleet service about any updates (included with next heartbeat)
fleetManager.setActivePlayerCount(5) // for automatic player capacity
fleetManager.setIsAvailable(false)

// ✨ Tell fleet service server is closing
fleetManager.markAsShutdown()

Click here for full HTTPS example

import https from 'https';
import express from 'express';
import geckos from '@geckos.io/server';
import fleetManager from '@example-wrtc-fleet-service/server';

const MAX_PLAYERS = 12;

// Setup fleet manager
fleetManager.setApiToken(process.env.MY_FLEET_API_TOKEN);

// Setup Geckos to connect over HTTPS
const geckosServer = geckos();
const sslCert = loadSslCertificate(process.env.GAMESERVER_SSL_CERT);
const sslServer = https.createServer(sslCert, express());

geckosServer.addServer(sslServer);
sslServer.listen(process.env.GAMESERVER_PORT, () => {
  console.debug(`WebRTC signaling server SSL Enabled (HTTPS). Listening on port: ${process.env.GAMESERVER_PORT}`);

  // ✨ Register your game server
  if (process.env.environment === 'production') {
    fleetManager.register({
      version: process.env.MY_GAME_VERSION,
      region: process.env.GAMESERVER_REGION,
      address: {
        host: process.env.GAMESERVER_DOMAIN,
        port: process.env.GAMESERVER_PORT,
      },
      heartbeatInterval: 5_000, // Send fleet heartbeat pulse every ~5s
      playerCapacity: MAX_PLAYERS, // Declare maximum players. This is not the same as clients (e.g.
                                   // a client could connect as a spectator, or with 1+ guest players).
      // and more ...
    });
  }
});

// ✨ Later update certain properties for the next health check
fleetManager.updateActivePlayerCount(myGameWorld.players.length);
fleetManager.updateIsAvailable(myGameWorld.);

// Mark server as no longer available
fleetManager.markAsShutdown();

e.g. in your API:

Then in your game's central API you could trigger something like:

POST "https://api.example-wrtc-fleet-service.net/<your-fleet-name>/list"
{
   token: "<your-api-token>"
}

and get a list of available game servers, which you can use in your matchmaking logic.

Example response: List gameservers

[
  {
    "id": "038e053b-0205-4bc0-8fef-39c24a0ded59",
    "region": "europe-central",
    "gameVersion": "20d4ae0d4dc245fb9c50435f5aa5c8b0",
    "available": true,
    "state": "healthy",
    "address": {
      "host": "https://gs-234-123-45-156.gameservers.example-wrtc-fleet-service.net",
      "port": 3233
    },
    "players": {
      "capacity": null,
      "reserved": 0,
      "active": 11
    },
    "aliveSince": 1716445331,
    "lastUpdated": 1716453224,
    "tags": [
      "casual"
    ]
  },
  {
    "id": "a9222aff-e52f-4daf-9321-3d28acbfa738",
    "region": "north-america-east",
    "gameVersion": "20d4ae0d4dc245fb9c50435f5aa5c8b0",
    "available": false,
    "state": "healthy",
    "address": {
      "host": "https://gs-55-124-23-121.gameservers.example-wrtc-fleet-service.net",
      "port": 8911
    },
    "players": {
      "capacity": 8,
      "reserved": 8,
      "active": 8
    },
    "aliveSince": 1716445456,
    "lastUpdated": 1716453225,
    "tags": [
      "ranked"
    ]
  },
  {
    "id": "21d15ee4-3e66-49b1-ac31-96aa230c73f2",
    "region": "north-america-east",
    "gameVersion": "b9c50435fe0d4dc245f5aa5c820d4ab0",
    "available": false,
    "state": "shutting-down",
    "address": null,
    "players": {
      "capacity": 8,
      "reserved": 8,
      "active": 7
    },
    "aliveSince": 1716445456,
    "lastUpdated": 1716453210,
    "tags": [
      "ranked",
      "game-ended"
    ]
  }
]

Benefits

• Simple, no-frills server management.
• Multi-region support out-of-the-box.
• Cheap. Uses shared hardware - so could probably offer a free tier or cheap basic tier for small/dev projects.
• Compatible with custom hardware(?) so you could use fleet management with your own dev servers.

Cons

• Not particularly useful for games that have persistent servers, like battle royale games, etc.

cc @Quitalizner @yandeu @JayeMcC @Not-Jayden

[Quitalizner]

@reececomo

The biggest advantage I see with a service like this is how it lowers the barrier for entry for fellow game developers.

A lot of folks aren't too savvy with the devOps stuff needed for WebRTC, and terms like ICE and TURN servers can easily intimidate many (I know I was).

I was very close to giving up when setting up Geckos.io on prod for the first time; there were just too many unknowns for me back then.

[reececomo]

Yeah, I have to imagine a bunch of devs start (and end) with persistent servers - e.g. battle royale games, agar.io clones - and never venture beyond there.

With the rapid development of WebGPU, it won't be long before competitive real-time games - e.g. FPS, RTS and fighting games - will be fully supported in the browser.

[Quitalizner]

I've been hearing the word WebGPU for a few years now.

Some game frameworks like CocosCreator have experimental version of WebGPU.
Waiting for the day when it becomes official.

[reececomo]

PixiJS 8 added support for it, and that chrome update above is from Feb 2024, so expecting big updates 2024/2025.

[reececomo]

We could just publish a tutorial/blog + terraform sample?

The minimum monthly cost is still fairly high, but in speaking to a few JS game developers - infra seems to be their big hurdle that stops them pursuing multiplayer 🤷‍♀️

[Quitalizner]

Yeah, that would be a nice initiative