Deploying a Game Server

This guide provides an example of manually building, deploying, and interacting with game servers.

Overview

You can easily build and deploy your Metaplay game server following a few steps laid out on this page. Here's an overview of what's ahead:

Setting up context variables
Building the server
Push to Metaplay
Deploying the built server

You'll also learn how to delete a server if needed.

To build and deploy game servers into Metaplay’s cloud, you’ll need the following tools:

You can optionally use kubectl or k9s too.

Setting up the context

For convenience, we can set up some environment variables, which we will refer to in the rest of this document. For eventual automation purposes, keeping these values at hand is also convenient to more easily create reproducible game server build and deploy flows.

bash

# Metaplay-hosted development environments are currently run in eu-west-1 region.
export AWS_REGION="eu-west-1"

# Metaplay's AWS account ID where the development environments are run.
export METAPLAY_AWS_ACCOUNT_ID="252344532344"

# Name of the game server deployment. For convenience purposes, we follow a
# convention where many of the resources are named after the deployment name.
export METAPLAY_DEPLOYMENT_NAME="idler-develop"

# The AWS IAM role which will be used to interact with Docker image repositories
# and game server AWS Secrets Manager secrets. Talk to Metaplay about setting
# this role up (the role trust configurations, etc.).
export METAPLAY_AWS_ROLE_NAME="MetaplayCiDeployment"
export METAPLAY_AWS_ROLE_ARN="arn:aws:iam::${METAPLAY_AWS_ACCOUNT_ID}:role/${METAPLAY_AWS_ROLE_NAME}"

# AWS ECR repository address where built game server Docker images will be pushed.
export METAPLAY_SERVER_ECR_REPO="${METAPLAY_AWS_ACCOUNT_ID}.dkr.ecr.${AWS_REGION}.amazonaws.com/metaplay-${METAPLAY_DEPLOYMENT_NAME}-server"

# AWS Secrets Manager secret, which contains details required for doing a deployment.
export METAPLAY_DEPLOYMENT_SECRET="metaplay/p1/deployments/${METAPLAY_DEPLOYMENT_NAME}"

Building the server

bash

# Tag for the image that we're building. Will be referred to in other parts of
# the flow. You will want to often tag the image with a commit id or a version
# name, but for the sake of example, we will just use `latest`.
export IMAGE_TAG="latest"

docker build \
  --pull \
  --platform linux/amd64 \
  -f MetaplaySDK/Dockerfile.server \
  -t ${METAPLAY_DEPLOYMENT_NAME}:${IMAGE_TAG} \
  .

Pushing the server to Metaplay

Configure the AWS Profile

The easiest way to gain access to pushing game server images to Metaplay’s AWS ECR repositories is to use the AWS IAM role specified above in METAPLAY_AWS_ROLE_ARN. You can achieve this by, for example, configuring an appropriate AWS profile in ~/.aws/credentials:

bash

[metaplay]
role_arn=*[insert actual value of $METAPLAY_AWS_ROLE_ARN]*
source_profile=default

# default AWS credentials
[default]
aws_access_key_id=...
aws_secret_access_key=...AWghhdo

After this, you can verify that the role works:

bash

$ export AWS_PROFILE="metaplay"
$ aws sts get-caller-identity
{
    "UserId": "AROATVQHH7V4BYP22WMAO:botocore-session-1663183787",
    "Account": "252344532344",
    "Arn": "arn:aws:sts::252344532344:assumed-role/..."
}

Tagging and pushing a game server image

bash

# set correct AWS profile
export AWS_PROFILE="metaplay"

# tag the image
docker tag ${METAPLAY_DEPLOYMENT_NAME}:${IMAGE_TAG} ${METAPLAY_SERVER_ECR_REPO}:${IMAGE_TAG}

# authenticate to ECR
aws ecr get-login-password --region ${AWS_REGION} | docker login --username AWS --password-stdin ${METAPLAY_AWS_ACCOUNT_ID}.dkr.ecr.${AWS_REGION}.amazonaws.com

# push image to Metaplay's ECR repo
docker push ${METAPLAY_SERVER_ECR_REPO}:${IMAGE_TAG}

Deploying a game server

Once you have pushed the game server image to Metaplay, you can deploy it using Helm.

Helm values

Firstly, you should craft a Helm values file for the environment where you're deploying the game server. Here is an example of such a file:

bash

# Write the Helm values into a file that we can use later and switch out some
# parts with our environment variables.
cat <<EOT >> ${METAPLAY_DEPLOYMENT_NAME}.yaml
environment: dev
environmentFamily: Development
hostname: ${METAPLAY_DEPLOYMENT_NAME}.p1.metaplay.io
image:
  repository: ${METAPLAY_SERVER_ECR_REPO}
  tag: latest # can be also overridden during Helm deployment time
  pullSecrets: aws-ecr
config:
  files:
    - "./Config/Options.base.yaml"
#    - "./Config/Options.dev.yaml" # add additional required runtime options
  extraEnv:
    - name: Metaplay_PushNotification__Enabled # as an example; can be used to override specific runtime options
      value: "false"

# deploy a single shard which runs all entities
shards:
  - name: all
    singleton: true
    requests:
      cpu: 50m
      memory: 100Mi

admin:
  enabled: true
  annotations:
    nginx.ingress.kubernetes.io/proxy-body-size: "20m"
  tls:
    enabled: true

# authentication is provided by Metaplay, used for LiveOps dashboard and observability tooling
auth:
  type: auth0
  enabled: true
  # Request these details from Metaplay to use Metaplay's identity provider!

# observability tooling
experimental:
  infraLoki:
    enabled: true
grafana:
  enabled: true
prometheus:
  enabled: true
EOT

Helm deployment

To deploy the game server, we’ll need to obtain a functioning kubeconfig for authenticating with Kubernetes. These are provided per environment and can be fetched from the corresponding AWS Secrets Manager secret for the environment. For example:

bash

$ export AWS_PROFILE="metaplay"
$ aws secretsmanager get-secret-value \
    --secret-id ${METAPLAY_DEPLOYMENT_SECRET} \
    --region ${AWS_REGION} | \
  jq -r .SecretString | \
  jq -r .deployment_kubeconfig | \
  base64 -d > kubeconfig.yaml
$ chmod go-rwx kubeconfig.yaml # restrict permissions to the file; consider wiping the file after usage in CI/CD systems
$ export KUBECONFIG=kubeconfig.yaml

Once the kubeconfig has been fetched and configured and assuming that the above Helm values file exists in, for example, ${METAPLAY_DEPLOYMENT_NAME}.yaml, as created in the previous step, we can deploy the game server using Helm:

bash

$ helm upgrade \
    --install \                           # if deployment doesn't exist, install it
    --repo https://charts.metaplay.dev/ \ # metaplay helm chart repo address
    --version 0.5.2 \                     # metaplay-gameserver helm chart version to use
    -n ${METAPLAY_DEPLOYMENT_NAME} \      # kubernetes namespace to deploy in
    -f ${METAPLAY_DEPLOYMENT_NAME}.yaml \ # values yaml to use
    --set-string image.tag=${IMAGE_TAG} \ # optionally override image tag to use
    ${METAPLAY_DEPLOYMENT_NAME} \         # name for helm deployment
    metaplay-gameserver                   # helm chart name
NAME: *[deployment name]*
LAST DEPLOYED: Wed Sep 14 21:58:46 2022
NAMESPACE: *[deployment namespace]*
STATUS: deployed
REVISION: 1
NOTES:
Installed *[deployment name]*

Release:
  Release name:      *[deployment name]*
  Release namespace: *[deployment namespace]*
  Chart name:        metaplay-gameserver
  Chart version:     0.5.2
Game server:
  Image: *[image repository url]*:*[image tag]*
Endpoints:
  Server:      tcp://*[deployment name]*.p1.metaplay.io:[9339]
  Server IPv6: tcp://*[deployment name]*-ipv6.p1.metaplay.io:[9339]
  Admin:       https://*[deployment name]*-admin.p1.metaplay.io/
  Grafana:     https://*[deployment name]*-admin.p1.metaplay.io/grafana/
  Prometheus:  https://*[deployment name]*-admin.p1.metaplay.io/prometheus/

Shards:
- name: all
  requests:
    cpu: 50m
    memory: 100Mi
  singleton: true

You can test that your deployment has succeeded by running Helm tests:

helm test --namespace *[deployment namespace]* *[deployment name]*
$

The Helm update or install operation output will give you the details about the endpoints available to access the game server.

Testing the deployment

bash

# For convenience purposes, both the deployment namespace (designated with the
# `-n` switch) and the deployment name are the same. These come from the above
# Helm install.
$ helm test -n ${METAPLAY_DEPLOYMENT_NAME} ${METAPLAY_DEPLOYMETN_NAME}
NAME: *[deployment name]*
LAST DEPLOYED: Wed Sep 14 21:58:46 2022
NAMESPACE: *[deployment namespace]*
STATUS: deployed
REVISION: 1
TEST SUITE:     *[deployment name]*-grafana-test
Last Started:   Wed Sep 14 22:47:12 2022
Last Completed: Wed Sep 14 22:47:20 2022
Phase:          Succeeded
TEST SUITE:     *[deployment name]*-test-gameserver-admin-health
Last Started:   Wed Sep 14 22:47:20 2022
Last Completed: Wed Sep 14 22:47:26 2022
Phase:          Succeeded
TEST SUITE:     *[deployment name]*-test-gameserver-endpoint-9339
Last Started:   Wed Sep 14 22:47:26 2022
Last Completed: Wed Sep 14 22:47:32 2022
Phase:          Succeeded
NOTES:

*[... same notes as during `helm upgrade` and `helm install`...]*

Deleting a game server

If you need to uninstall or delete a game server, you can use helm delete:

bash

$ helm ls -n ${METAPLAY_DEPLOYMENT_NAME}
NAME              NAMESPACE         REVISION  UPDATED                               STATUS    CHART                     APP VERSION
*[deployment name]* *[deployment name]* 1         2022-09-14 21:58:46.317025 +0300 EEST deployed  metaplay-gameserver-0.5.2
$ helm delete -n ${METAPLAY_DEPLOYMENT_NAME} ${METAPLAY_DEPLOYMENT_NAME}
release "*[deployment name]*" uninstalled
$

Release Notes

Release 27

Release 25

Open Source Software Licenses

Deploying a Game Server

Overview

Setting up the context

Building the server

Pushing the server to Metaplay

Configure the AWS Profile

Tagging and pushing a game server image

Deploying a game server

Helm values

Helm deployment

Testing the deployment

Deleting a game server

Release 27

Release 25

Deploying a Game Server

Overview ​

Setting up the context ​

Building the server ​

Pushing the server to Metaplay ​

Configure the AWS Profile ​

Tagging and pushing a game server image ​

Deploying a game server ​

Helm values ​

Helm deployment ​

Testing the deployment ​

Deleting a game server ​

Overview

Setting up the context

Building the server

Pushing the server to Metaplay

Configure the AWS Profile

Tagging and pushing a game server image

Deploying a game server

Helm values

Helm deployment

Testing the deployment

Deleting a game server