feature: use docker to run game servers (#111)

* feature: use docker to run game servers

* use docker image from game version

* migrate game deployment query from mysql to graphql

* use ports from game_version

Author: dhenkel92

async-server-provisioner/config/custom-environment-variables.yml

@@ -15,3 +15,7 @@ hcloudServer:
 datadog:
   enabled: DD_ENABLED
   api_key: DD_API_KEY
+
+cloudGame:
+  apiUrl: CLOUD_GAME_API_URL
+  apiToken: CLOUD_GAME_API_TOKEN

async-server-provisioner/config/default.yml

@@ -11,9 +11,13 @@ hetzner:
 
 hcloudServer:
   type: cx31
-  image: '162583525'
+  image: '162606073'
   location: nbg1
 
 datadog:
   enabled: false
   api_key: placeholder
+
+cloudGame:
+  apiUrl: http://host.docker.internal:1337
+  apiToken: placeholder

async-server-provisioner/src/adapters/GraphQlAdapter.ts

@@ -0,0 +1,19 @@
+import * as config from 'config';
+
+const apiUrl = config.get<string>('cloudGame.apiUrl');
+
+export async function gqlQuery(query: string, data: any): Promise<any> {
+  const res = await fetch(`${apiUrl}/graphql`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Accept: 'application/json',
+      Authorization: config.get<string>('cloudGame.apiToken'),
+    },
+    body: JSON.stringify({
+      query,
+      variables: data,
+    }),
+  });
+  return res.json();
+}

async-server-provisioner/src/entities/CloudInstance.ts

@@ -7,9 +7,9 @@ export interface CloudInstance {
 
 export function cloudInstanceFactory(row: any): CloudInstance {
   return {
-    provider: row.ci_provider,
-    apiName: row.ci_api_name,
-    costPerHour: row.ci_cost_per_hour,
-    region: row.ci_region,
+    provider: row.data.attributes.provider,
+    apiName: row.data.attributes.api_name,
+    costPerHour: row.data.attributes.cost_per_hour,
+    region: row.data.attributes.region,
   };
 }

async-server-provisioner/src/entities/GameDeployment.ts

@@ -8,26 +8,26 @@ export enum GameDeploymentStatus {
 
 export interface GameDeployment {
   id: number;
-  workspaceName: string;
   consumerUUID: string;
   status: GameDeploymentStatus;
   cloudInstance: CloudInstance;
   gameInstance: GameInstance;
 }
 
-function generateTFWorkspaceName(row: any): string {
-  const rawString = `${row.gi_id}-${row.gi_name}`;
+export function generateTFWorkspaceName(deploy: GameDeployment): string {
+  const rawString = `${deploy.id}-${deploy.gameInstance.name}`;
   return rawString.replace(/([\s-_])/g, '-').toLowerCase();
 }
 
-export function gameDeploymentFactory(row: any): GameDeployment {
-  const workspaceName = generateTFWorkspaceName(row);
+export function gameDeploymentFactory(consumerUid: string, row: any): GameDeployment {
+  const gameDeployment = row.data.gameDeployment;
+  const cloudInstance = gameDeployment.data.attributes.cloud_instance;
+  const gameInstance = gameDeployment.data.attributes.game_instance;
   return {
-    workspaceName,
-    id: row.gd_id,
-    consumerUUID: row.gd_consumer_uuid,
-    status: (GameDeploymentStatus as any)[row.gd_status],
-    cloudInstance: cloudInstanceFactory(row),
-    gameInstance: gameInstanceFactory(row),
+    id: gameDeployment.data.id,
+    consumerUUID: consumerUid,
+    status: (GameDeploymentStatus as any)[gameDeployment.data.attributes.status],
+    cloudInstance: cloudInstanceFactory(cloudInstance),
+    gameInstance: gameInstanceFactory(gameInstance),
   };
 }

async-server-provisioner/src/entities/GameInstance.ts

@@ -1,11 +1,33 @@
 export interface GameInstance {
   name: string;
   dockerImage: string;
+  ports: GameInstancePort[];
+}
+
+export enum GameInstancePortType {
+  UDP = 'UDP',
+  TCP = 'TCP',
+}
+
+export interface GameInstancePort {
+  name: string;
+  port: number;
+  type: GameInstancePortType;
 }
 
 export function gameInstanceFactory(row: any): GameInstance {
+  const gameVersion = row.data.attributes.game_version;
+  return {
+    name: row.data.attributes.name,
+    dockerImage: gameVersion.data.attributes.docker_image,
+    ports: gameVersion.data.attributes.ports.map(parseGameInstancePort),
+  };
+}
+
+function parseGameInstancePort(raw: any): GameInstancePort {
   return {
-    name: row.gi_name,
-    dockerImage: row.gv_docker_image,
+    name: raw.name,
+    port: raw.port,
+    type: (GameInstancePortType as any)[raw.type],
   };
 }

async-server-provisioner/src/entities/MinecraftTFConfig.ts

@@ -1,5 +1,5 @@
 import * as config from 'config';
-import { GameDeployment } from './GameDeployment';
+import { GameDeployment, generateTFWorkspaceName } from './GameDeployment';
 
 export interface MinecraftTFConfig {
   metadata: {
@@ -10,6 +10,11 @@ export interface MinecraftTFConfig {
     type: string;
     image: string;
     docker_image: string;
+    ports: {
+      proto: string;
+      port: string;
+      description: string;
+    }[];
   };
   datadog: {
     enabled: boolean;
@@ -26,13 +31,18 @@ export function mcTFConfToTFArgs(mfConfig: MinecraftTFConfig): string {
 export function createMinecraftTFConfigFromGameConfig(mfConfig: GameDeployment): MinecraftTFConfig {
   return {
     metadata: {
-      name: mfConfig.workspaceName,
+      name: generateTFWorkspaceName(mfConfig),
       location: mfConfig.cloudInstance.region,
     },
     server: {
       type: mfConfig.cloudInstance.apiName,
       image: config.get('hcloudServer.image'),
-      docker_image: 'cloudgame/minecraft:vanilla-1.18.2',
+      docker_image: mfConfig.gameInstance.dockerImage,
+      ports: mfConfig.gameInstance.ports.map((port) => ({
+        proto: port.type.toLowerCase(),
+        port: `${port.port}`,
+        description: port.name,
+      })),
     },
     datadog: {
       enabled: config.get('datadog.enabled'),

async-server-provisioner/src/repositories/GameDeploymentRepository.ts

@@ -2,6 +2,49 @@ import MySqlAdapter from '../adapters/MySqlAdapter';
 import { GameDeployment, gameDeploymentFactory } from '../entities/GameDeployment';
 import { v4 } from 'uuid';
 import { TerraformGSOutput } from '../services/TerraformService';
+import { gqlQuery } from '../adapters/GraphQlAdapter';
+
+const query = `
+query($id: ID) {
+  gameDeployment(id: $id) {
+    data {
+      id
+      attributes {
+        status
+        cloud_instance {
+          data {
+            attributes {
+              api_name
+              provider
+              region
+              cost_per_hour
+            }
+          }
+        }
+        game_instance {
+          data {
+            attributes {
+              name
+              game_version {
+                data {
+                  attributes {
+                    docker_image
+                    ports {
+                      name
+                      port
+                      type
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+`;
 
 export default class GameDeploymentRepository {
   constructor(
@@ -24,14 +67,8 @@ export default class GameDeploymentRepository {
 
     const rows = await this.dirtyMysqlAdapter.query(
       `
-      SELECT gd.id as gd_id, gd.status as gd_status, gd.consumer_uuid as gd_consumer_uuid, ci.provider as ci_provider, ci.api_name as ci_api_name, ci.cost_per_hour as ci_cost_per_hour, ci.region as ci_region, gi.id as gi_id, gi.name as gi_name, gv.docker_image as gv_docker_image
+      SELECT gd.id as gd_id
       FROM game_deployments gd
-        INNER JOIN game_deployments_game_instance_links gil ON gil.game_deployment_id = gd.id
-        INNER JOIN game_instances gi ON gil.game_instance_id = gi.id
-        INNER JOIN game_instances_game_version_links gvl ON gvl.game_instance_id = gi.id
-        INNER JOIN game_versions gv ON gv.id = gvl.game_version_id
-        INNER JOIN game_deployments_cloud_instance_links cil ON cil.game_deployment_id = gd.id
-        INNER JOIN cloud_instances ci ON ci.id = cil.cloud_instance_id
       WHERE consumer_uuid = ?;
     `,
       [uuid]
@@ -41,7 +78,11 @@ export default class GameDeploymentRepository {
       return null;
     }
 
-    return gameDeploymentFactory(rows[0]);
+    const data = await gqlQuery(query, { id: rows[0].gd_id });
+    const gameDeployment = gameDeploymentFactory(uuid, data);
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify(gameDeployment, null, 2));
+    return gameDeployment;
   }
 
   public async failedDeployment(): Promise<void> {

async-server-provisioner/src/services/GameDeploymentService.ts

@@ -2,7 +2,7 @@ import { Logger } from 'pino';
 import GameDeploymentRepository from '../repositories/GameDeploymentRepository';
 import { TerraformService } from './TerraformService';
 import { HetznerCloudRepository } from '../repositories/HetznerCloudRepository';
-import { GameDeploymentStatus } from '../entities/GameDeployment';
+import { GameDeploymentStatus, generateTFWorkspaceName } from '../entities/GameDeployment';
 
 export interface GameDeploymentServiceConfig {
   timeoutMillis?: number;
@@ -61,7 +61,7 @@ export class GameDeploymentService {
     this.logger.info('received new message %s', JSON.stringify(res));
     try {
       if (res.status === GameDeploymentStatus.STOPPING) {
-        await this.shutdownHetznerServer(res.workspaceName);
+        await this.shutdownHetznerServer(generateTFWorkspaceName(res));
       }
 
       this.logger.info('start terraform execution');

async-server-provisioner/src/services/TerraformService.ts

@@ -1,6 +1,6 @@
 import { Logger } from 'pino';
 import { ShellAdapter, ShellResult } from '../adapters/ShellAdapter';
-import { GameDeployment, GameDeploymentStatus } from '../entities/GameDeployment';
+import { GameDeployment, GameDeploymentStatus, generateTFWorkspaceName } from '../entities/GameDeployment';
 import { GameDeploymentLogRepository } from '../repositories/GameDeploymentLogRepository';
 import { createMinecraftTFConfigFromGameConfig, mcTFConfToTFArgs, MinecraftTFConfig } from '../entities/MinecraftTFConfig';
 
@@ -21,7 +21,7 @@ export class TerraformService {
   public async execute(config: GameDeployment): Promise<TerraformGSOutput | null> {
     const tfVars = createMinecraftTFConfigFromGameConfig(config);
     await this.init(config.id);
-    await this.changeWorkspace(config.id, config.workspaceName);
+    await this.changeWorkspace(config.id, generateTFWorkspaceName(config));
 
     switch (config.status) {
       case GameDeploymentStatus.STARTING:

docker-compose.yaml

@@ -44,6 +44,7 @@ services:
       - MYSQL_HOST=db
       - TERRAFORM_PATH=/opt/terraform/02-game-server
       - HCLOUD_TOKEN=${HCLOUD_TOKEN}
+      - CLOUD_GAME_API_TOKEN=${CLOUD_GAME_API_TOKEN}
     volumes:
       - ~/.aws:/root/.aws
       - ./async-server-provisioner:/usr/src/app

infrastructure/ansible/roles/base-server/tasks/prepare-server.yml

@@ -2,10 +2,11 @@
 - name: Install common packages
   apt:
     pkg:
-    - telnet
-    - vim
-    - tcpdump
-    - gnupg2
+      - telnet
+      - vim
+      - tcpdump
+      - gnupg2
+      - git
     state: present
     update_cache: true
 

infrastructure/terraform/02-game-server/files/startup.sh

@@ -19,4 +19,5 @@ watcher:
   port: 8080
 EOF
 
-ansible-playbook /root/ansible/game-server-start.yml --extra-vars "@/root/ansible/vars/game-server.yaml"
+git clone -b ${ansible_branch} https://github.com/dhenkel92/cloud-gameserver.git /tmp/cloud-gameserver
+ansible-playbook /tmp/cloud-gameserver/infrastructure/ansible/game-server-start.yml --extra-vars "@/root/ansible/vars/game-server.yaml"

infrastructure/terraform/02-game-server/main.tf

@@ -1,5 +1,7 @@
 locals {
-  tags = merge(var.tags, {})
+  tags           = merge(var.tags, {})
+  default_rules  = [{ proto = "tcp", port = "22", description = "ssh" }]
+  firewall_rules = concat(local.default_rules, var.server.ports)
 }
 
 data "terraform_remote_state" "aws_platform" {
@@ -24,23 +26,28 @@ module "firewall" {
   source = "../modules/firewall"
 
   name = var.metadata.name
-  rules = [
-    {
-      proto      = "tcp"
-      port       = "22"
-      source_ips = ["0.0.0.0/0"]
-    },
-    {
-      proto      = "tcp"
-      port       = "25565"
-      source_ips = ["0.0.0.0/0"]
-    },
-    {
-      proto      = "tcp"
-      port       = "8080"
-      source_ips = ["0.0.0.0/0"]
-    }
-  ]
+  rules = [for rule in local.firewall_rules : {
+    proto       = rule.proto
+    port        = rule.port
+    description = rule.description
+    source_ips  = ["0.0.0.0/0"]
+  }]
+  # rules = [
+  # {
+  # proto      = "tcp"
+  # port       = "22"
+  # },
+  # {
+  # proto      = "tcp"
+  # port       = "25565"
+  # source_ips = ["0.0.0.0/0"]
+  # },
+  # {
+  # proto      = "tcp"
+  # port       = "8080"
+  # source_ips = ["0.0.0.0/0"]
+  # }
+  # ]
 }
 
 module "game_server" {
@@ -69,6 +76,7 @@ module "game_server" {
       datadog_api_key       = var.datadog.api_key
       aws_access_key_id     = data.terraform_remote_state.aws_platform.outputs.access_keys["game_user.cloud-game"].access_key_id
       aws_secret_access_key = data.terraform_remote_state.aws_platform.outputs.access_keys["game_user.cloud-game"].secret_access_key
+      ansible_branch        = var.ansible_branch
     }
   }
 }