Agones

System Diagram

Thu, 18 Apr 2024 00:00:00 +0000

Agones Control Plane

The Agones Control Plane consists of 4 Deployments:

NAME                READY   UP-TO-DATE   AVAILABLE   AGE
agones-allocator    3/3     3            3           40d
agones-controller   2/2     2            2           40d
agones-extensions   2/2     2            2           40d
agones-ping         2/2     2            2           40d

`agones-allocator`

agones-allocator provides a gRPC/REST service that translates allocation requests into GameServerAllocations. See Allocator Service for more information.

`agones-controller`

agones-controller maintains various control loops for all Agones CRDs (GameServer, Fleet, etc.). A single leader-elected Pod of the Deployment is active at any given time (see High Availability).

Feature Stages

Thu, 26 Sep 2019 01:20:41 +0000

Supported Versions

Agones versions are expressed as x.y.z, where x is the major version, y is the minor version, and z is the patch version following Semantic Versioning terminology.

Agones Features

A feature within Agones can be in Alpha, Beta or Stable stage.

Feature Gates

Alpha and Beta features can be enabled or disabled through the agones.featureGates configuration option that can be found in the Helm configuration documentation. Stable features are always enabled, and exist for upgrade compatibility, and cannot be disabled.

Matchmaker requests a GameServer from a Fleet

Tue, 27 Jul 2021 00:00:00 +0000

Sample `GameServerAllocation`

Since Agones will automatically add the label agones.dev/fleet to a GameServer of a given Fleet, we can use that label selector to target a specific Fleet by name. In this instance, we are targeting the Fleet xonotic.

apiVersion: "allocation.agones.dev/v1"
kind: GameServerAllocation
spec:
  selectors:
    - matchLabels:
        agones.dev/fleet: xonotic

Next Steps:

Read the various specification references.
- Review the GameServer spec.
- Review the Fleet spec.
- Review the GameServerAllocation spec.
Review the specifics of Health Checking.
See all the commands the Client SDK provides - we only show a few here!
Check out the Allocator Service as a richer alternative to GameServerAllocation.
If you aren’t familiar with the term Pod, this should provide a reference.

Unreal Engine Game Server Client Plugin

Mon, 13 May 2019 00:00:00 +0000

Check the Client SDK Documentation for more details on each of the SDK functions and how to run the SDK locally.

SDK Functionality

Area	Action	Implemented
Lifecycle	Ready	✔️
Lifecycle	Health	✔️
Lifecycle	Reserve	✔️
Lifecycle	Allocate	✔️
Lifecycle	Shutdown	✔️
Configuration	GameServer	✔️
Configuration	Watch	✔️
Metadata	SetAnnotation	✔️
Metadata	SetLabel	✔️
Counters	GetCounterCount	✔️
Counters	SetCounterCount	✔️
Counters	IncrementCounter	✔️
Counters	DecrementCounter	✔️
Counters	SetCounterCapacity	✔️
Counters	GetCounterCapacity	✔️
Lists	GetList	✔️
Lists	UpdateList	✔️
Lists	AddListValue	✔️
Lists	RemoveListValue	✔️
Player Tracking	GetConnectedPlayers	✔️
Player Tracking	GetPlayerCapacity	✔️
Player Tracking	GetPlayerCount	✔️
Player Tracking	IsPlayerConnected	✔️
Player Tracking	PlayerConnect	✔️
Player Tracking	PlayerDisconnect	✔️
Player Tracking	SetPlayerCapacity	✔️

Additional methods have been added for ease of use (both of which are enabled by default):

Third Party Videos and Presentations

Thu, 03 Jan 2019 08:37:35 +0000

Case Studies

Engineering Without Limits: A Decade of Kubernetes Powering PlayStation’s Evolution (Kubecon NA, 2025)

No More Disruption: PlayStation Network’s Approaches To Avoid Outages on Kubernetes Platform (Kubecon Japan, 2025)

(Paywall) ‘Monster Hunter Wilds’ Network Architecture Supporting Over 1 Million Concurrent Users (Presented by AWS) (Devcom, 2025)

Unfortunately, it seems that only people who have previously registered for Devcom can view this video. If you find another way to access it, please submit a PR on this page!

Scheduling and Autoscaling

Thu, 03 Jan 2019 05:45:05 +0000

Cluster Autoscaler

Kubernetes has a cluster node autoscaler that works with a wide variety of cloud providers.

The default scheduling strategy (Packed) is designed to work with the Kubernetes autoscaler out of the box.

The autoscaler will automatically add Nodes to the cluster when GameServers don’t have room to be scheduled on the clusters, and then scale down when there are empty Nodes with no GameServers running on them.

This means that scaling Fleets up and down can be used to control the size of the cluster, as the cluster autoscaler will adjust the size of the cluster to match the resource needs of one or more Fleets running on it.

GameServer Specification

Thu, 03 Jan 2019 03:58:48 +0000

A full GameServer specification is available below and in the example folder for reference :

apiVersion: "agones.dev/v1"
kind: GameServer
# GameServer Metadata
# https://v1-34.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.34/#objectmeta-v1-meta
metadata:
  # generateName: "gds-example" # generate a unique name, with the given prefix
  name: "gds-example" # set a fixed name
spec:
  # if there is more than one container, specify which one is the game server
  container: example-server
  # Array of ports that can be exposed as direct connections to the game server container
  ports:
    # name is a descriptive name for the port
  - name: default
    # [Stage:Beta]
    # [FeatureFlag:PortRanges]
    # range is the optional port range name from which to select a port when using a 'Dynamic' or 'Passthrough' port policy.
    range: default
    # portPolicy has four options:
    # - "Dynamic" (default) the system allocates a free hostPort for the gameserver, for game clients to connect to
    # - "Static", user defines the hostPort that the game client will connect to. Then onus is on the user to ensure that the
    # port is available. When static is the policy specified, `hostPort` is required to be populated
    # - "Passthrough" dynamically sets the `containerPort` to the same value as the dynamically selected hostPort.
    #      This will mean that users will need to lookup what port has been opened through the server side SDK.
    # - "None" means the `hostPort` is ignored and if defined, the `containerPort` (optional) is used to set the port on the GameServer instance.
    portPolicy: Static
    # The name of the container to open the port on. Defaults to the game server container if omitted or empty.
    container: simple-game-server
    # the port that is being opened on the game server process
    containerPort: 7654
    # the port exposed on the host, only required when `portPolicy` is "Static". Overwritten when portPolicy is "Dynamic".
    hostPort: 7777
    # protocol being used. Defaults to UDP. TCP and TCPUDP are other options
    # - "UDP" (default) use the UDP protocol
    # - "TCP", use the TCP protocol
    # - "TCPUDP", uses both TCP and UDP, and exposes the same hostPort for both protocols.
    #       This will mean that it adds an extra port, and the first port is set to TCP, and second port set to UDP
    protocol: UDP
  # Health checking for the running game server
  health:
    # Disable health checking. defaults to false, but can be set to true
    disabled: false
    # Number of seconds after the container has started before health check is initiated. Defaults to 5 seconds
    initialDelaySeconds: 5
    # If the `Health()` function doesn't get called at least once every period (seconds), then
    # the game server is not healthy. Defaults to 5
    periodSeconds: 5
    # Minimum consecutive failures for the health probe to be considered failed after having succeeded.
    # Defaults to 3. Minimum value is 1
    failureThreshold: 3
  # Parameters for game server sidecar
  sdkServer:
    # sdkServer log level parameter has three options:
    #  - "Info" (default) The SDK server will output all messages except for debug messages
    #  - "Debug" The SDK server will output all messages including debug messages
    #  - "Error" The SDK server will only output error messages
    #  - "Trace" The SDK server will output all messages, including detailed tracing information
    logLevel: Info
    # grpcPort and httpPort control what ports the sdkserver listens on.
    # Starting with Agones 1.2 the default grpcPort is 9357 and the default
    # httpPort is 9358. In earlier releases, the defaults were 59357 and 59358
    # respectively but as these were in the ephemeral port range they could
    # conflict with other TCP connections.
    grpcPort: 9357
    httpPort: 9358
  # [Stage:Alpha]
  # [FeatureFlag:PlayerTracking]
  # Players provides the configuration for player tracking features.
  # Commented out since Alpha, and disabled by default
  # players:
  #   # set this GameServer's initial player capacity
  #   initialCapacity: 10
  #
  # [Stage:Beta]
  # [FeatureFlag:CountsAndLists]
  # Counts and Lists provides the configuration for generic (player, room, session, etc.) tracking features.
  # Now in Beta, and enabled by default
  counters: # counters are int64 counters that can be incremented and decremented by set amounts. Keys must be declared at GameServer creation time.
    rooms: # arbitrary key.
      count: 1 # initial value can be set.
      capacity: 100 # (Optional) Defaults to 1000 and setting capacity to max(int64) may lead to issues and is not recommended. See GitHub issue https://github.com/agones-dev/agones/issues/3636 for more details.
  lists: # lists are lists of values stored against this GameServer that can be added and deleted from. Keys must be declared at GameServer creation time.
    players: # an empty list, with a capacity set to 10.
      capacity: 10 # capacity value, defaults to 1000.
    rooms: # note that it is allowed to have the same key name with one used in counters
      capacity: 333
      values: # initial values can also be set for lists
        - room1
        - room2
        - room3
  # Pod template configuration
  # https://v1-34.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.34/#podtemplate-v1-core
  template:
    # pod metadata. Name & Namespace is overwritten
    metadata:
      labels:
        myspeciallabel: myspecialvalue
    # Pod Specification
    spec:
      containers:
      - name: simple-game-server
        image:  us-docker.pkg.dev/agones-images/examples/simple-game-server:0.40
        imagePullPolicy: Always
      # nodeSelector is a label that can be used to tell Kubernetes which host
      # OS to use. For Windows game servers uncomment the nodeSelector
      # definition below.
      # Details: https://kubernetes.io/docs/setup/production-environment/windows/user-guide-windows-containers/#ensuring-os-specific-workloads-land-on-the-appropriate-container-host
      # nodeSelector:
      #   kubernetes.io/os: windows

Since Agones defines a new Custom Resources Definition (CRD) we can define a new resource using the kind GameServer with the custom group agones.dev and API version v1.

Quickstart: Create a Game Server

Wed, 02 Jan 2019 06:35:31 +0000

Prerequisites

The following prerequisites are required to create a GameServer:

A Kubernetes cluster with the UDP port range 7000-8000 open on each node. Creating the firewall.
Agones controller installed in the targeted cluster
kubectl properly configured
Netcat which is already installed on most Linux/macOS distributions, for windows you can use WSL.

If you don’t have a Kubernetes cluster you can follow these instructions to create a cluster on Google Kubernetes Engine (GKE), Minikube or Azure Kubernetes Service (AKS), and install Agones.

Google Kubernetes Engine

Mon, 01 Jan 0001 00:00:00 +0000

Before you begin

Take the following steps to enable the Kubernetes Engine API:

Visit the Kubernetes Engine page in the Google Cloud Platform Console.
Create or select a project.
Wait for the API and related services to be enabled. This can take several minutes.
Enable billing for your project.

If you are not an existing GCP user, you may be able to enroll for a $300 US Free Trial credit.

Choosing a shell

To complete this quickstart, we can use either Google Cloud Shell or a local shell.

Installing Agones on Google Kubernetes Engine using Terraform

Mon, 01 Jan 0001 00:00:00 +0000

Before you begin

Take the following steps to enable the Kubernetes Engine API:

Visit the Kubernetes Engine page in the Google Cloud Platform Console.
Create or select a project.
Wait for the API and related services to be enabled. This can take several minutes.
Enable billing for your project.

If you are not an existing GCP user, you may be able to enroll for a $300 US Free Trial credit.

Choosing a shell

To complete this quickstart, we can use either Google Cloud Shell or a local shell.

Install Agones using YAML

Mon, 01 Jan 0001 00:00:00 +0000

Installing Agones

Warning

Installing Agones with the install.yaml file will use pre-generated, well known TLS certificates stored in this repository for securing Kubernetes webhooks communication.

For production workloads, we strongly recommend using the helm installation which allows you to generate new, unique certificates or provide your own certificates. Alternatively, you can use helm template as described below to generate a custom yaml installation file with unique certificates.

Installing Agones using the pre-generated install.yaml file is the quickest, simplest way to get Agones up and running in your Kubernetes cluster:

Unity Game Server Client SDK

Thu, 13 Jun 2019 10:17:50 +0000

Check the Client SDK Documentation for more details on each of the SDK functions and how to run the SDK locally.

SDK Functionality

Area	Action	Implemented
Lifecycle	Ready	✔️
Lifecycle	Health	✔️
Lifecycle	Reserve	✔️
Lifecycle	Allocate	✔️
Lifecycle	Shutdown	✔️
Configuration	GameServer	✔️
Configuration	Watch	✔️
Metadata	SetAnnotation	✔️
Metadata	SetLabel	✔️
Counters	GetCounterCount	❌
Counters	SetCounterCount	❌
Counters	IncrementCounter	❌
Counters	DecrementCounter	❌
Counters	SetCounterCapacity	❌
Counters	GetCounterCapacity	❌
Lists	AppendListValue	❌
Lists	DeleteListValue	❌
Lists	SetListCapacity	❌
Lists	GetListCapacity	❌
Lists	ListContains	❌
Lists	GetListLength	❌
Lists	GetListValues	❌
Player Tracking	GetConnectedPlayers	✔️
Player Tracking	GetPlayerCapacity	✔️
Player Tracking	GetPlayerCount	✔️
Player Tracking	IsPlayerConnected	✔️
Player Tracking	PlayerConnect	✔️
Player Tracking	PlayerDisconnect	✔️
Player Tracking	SetPlayerCapacity	✔️

Additional methods have been added for ease of use:

Third Party Articles

Mon, 15 Dec 2025 00:00:00 +0000

Case Studies

2025

Sept 10 Bandai Namco and Google Cloud Partner to Launch ‘DRAGON BALL GEKISHIN SQUADRA,’ a New Cross-Platform Multiplayer Action Game
Nov 5 - Sonic Rumble Open Source Licences (This is mostly because I can’t find a recording of Sonic Rumbleのグローバルなマルチプレイ対戦サービスの裏側～Unity/Agones/AWS/EKSを用いてシンプルで疲労の少ない開発・運用を目指す～, but you can find slides at CEDIL (registration required))

2023

Feb 1 - (Japanese) Nintendo: Building a new general-purpose game server using Google Kubernetes Engine, Cloud Spanner, and more
Apr 4 - (Google Doodle) Making online containerized games with managed services
Jul 18 - Optimizing Gaijin Ent.’s Crossout for cost-efficiency and reliability using EKS, Karpenter and Agones

Blogs

High Availability Agones

Tue, 28 Feb 2023 00:00:00 +0000

High Availability for Agones Controller

The agones-controller responsibility is split up into agones-controller, which enacts the Agones control loop, and agones-extensions, which acts as a service endpoint for webhooks and the allocation extension API. Splitting these responsibilities allows the agones-extensions pod to be horizontally scaled, making the Agones control plane highly available and more resiliant to disruption.

Multiple agones-controller pods enabled, with a primary controller selected via leader election. Having multiple agones-controller minimizes downtime of the service from pod disruptions such as deployment updates, autoscaler evictions, and crashes.

Controlling Disruption

Tue, 24 Jan 2023 20:15:26 +0000

Disruption in Kubernetes

A Pod in Kubernetes may be disrupted for involuntary reasons, e.g. hardware failure, or voluntary reasons, such as when nodes are drained for upgrades.

By default, Agones assumes your game server should never be disrupted voluntarily and configures the Pod appropriately - but this isn’t always the ideal setting. Here we discuss how Agones allows you to control the two most significant sources of voluntary Pod evictions, node upgrades and Cluster Autoscaler, using the eviction API on the GameServer object.

Matchmaker requires game server process registration

Tue, 27 Jul 2021 00:00:00 +0000

In this scenario, the GameServer process will need to self Allocate when informed by the matchmaker that players are being sent to them.

Warning

This does relinquish control over how GameServers are packed across the cluster to the external matchmaker. It is likely it will not do as good a job at packing and scaling as Agones.

Next Steps:

Read the various references, including the GameServer and Fleet reference materials.
Review the specifics of Health Checking.
See all the commands the Client SDK provides - we only show a few here!
If you aren’t familiar with the term Pod, this should provide a reference.

Windows Gameservers

Tue, 27 Apr 2021 23:00:00 +0000

Warning

Running GameServers on Windows nodes is currently Alpha, and any feedback would be appreciated.

Prerequisites

The following prerequisites are required to create a GameServer:

A Kubernetes cluster with the UDP port range 7000-8000 open on each node. Creating the firewall.
Agones controller installed in the targeted cluster
kubectl properly configured
Netcat which is already installed on most Linux/macOS distributions, for windows you can use WSL.

If you don’t have a Kubernetes cluster you can follow these instructions to create a cluster on Google Kubernetes Engine (GKE), Minikube or Azure Kubernetes Service (AKS), and install Agones.

Installing Agones on AWS Elastic Kubernetes Service using Terraform

Tue, 21 Jan 2020 00:00:00 +0000

Installation

You can use Terraform to provision your Amazon EKS (Elastic Kubernetes Service) cluster and install Agones on it using the Helm Terraform provider.

An example of the EKS submodule config file can be found here: Terraform configuration with Agones submodule

Copy this file into a separate folder.

Configure your AWS CLI tool CLI configure:

aws configure

Initialise your terraform:

terraform init

Creating Cluster

By editing modules.tf you can change the parameters that you need to. For instance, the - machine_type variable.

Third Party Podcasts

Wed, 15 Jan 2020 00:00:00 +0000

2024

Mar 5 - (Dutch) Aflevering 43: Playstation games en Kubernetes

2021

Apr 30 - Level Design Podcast: LD039 - Taking the agony out of multiplayer games with Mark Mandel and Agones

2020

Mar 25th - FLOSS Weekly: 571 - Agones

2019

Nov 6 - Google Cloud Platform Podcast: Supersolid with Kami May

2018

Fleet Updates

Tue, 27 Aug 2019 03:58:19 +0000

Rolling Update Strategy

When Fleets are edited and updated, the default strategy of Agones is to roll the new version of the GameServer out to the entire Fleet, in a step by step increment and decrement by adding a chunk of the new version and removing a chunk of the current set of GameServers.

This is done while ensuring that Allocated GameServers are not deleted until they are specifically shutdown through the game servers SDK, as they are expected to have players on them.

Fleet Specification

Thu, 03 Jan 2019 03:58:52 +0000

To allocate a GameServer from a Fleet, use a GameServerAllocation.

Like any other Kubernetes resource you describe a Fleet’s desired state via a specification written in YAML or JSON to the Kubernetes API. The Agones controller will then change the actual state to the desired state.

A full Fleet specification is available below and in the example folder for reference :

apiVersion: "agones.dev/v1"
kind: Fleet
# Fleet Metadata
# https://v1-34.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.34/#objectmeta-v1-meta
metadata:
  name: fleet-example
spec:
  # the number of GameServers to keep Ready or Allocated in this Fleet
  replicas: 2
  # defines how GameServers are organised across the cluster.
  # Options include:
  # "Packed" (default) is aimed at dynamic Kubernetes clusters, such as cloud providers, wherein we want to bin pack
  # resources
  # "Distributed" is aimed at static Kubernetes clusters, wherein we want to distribute resources across the entire
  # cluster
  scheduling: Packed
  # a GameServer template - see:
  # https://agones.dev/site/docs/reference/gameserver/ for all the options
  strategy:
    # The replacement strategy for when the GameServer template is changed. Default option is "RollingUpdate",
    # "RollingUpdate" will increment by maxSurge value on each iteration, while decrementing by maxUnavailable on each
    # iteration, until all GameServers have been switched from one version to another.
    # "Recreate" terminates all non-allocated GameServers, and starts up a new set with the new details to replace them.
    type: RollingUpdate
    # Only relevant when `type: RollingUpdate`
    rollingUpdate:
      # the amount to increment the new GameServers by. Defaults to 25%
      maxSurge: 25%
      # the amount to decrements GameServers by. Defaults to 25%
      maxUnavailable: 25%
  # Labels and/or Annotations to apply to overflowing GameServers when the number of Allocated GameServers is more
  # than the desired replicas on the underlying `GameServerSet`
  allocationOverflow:
    labels:
      mykey: myvalue
      version: "" # empty an existing label value
    annotations:
      otherkey: setthisvalue
  # [Stage:Beta]
  # [FeatureFlag:CountsAndLists]
  # Which gameservers in the Fleet are most important to keep around - impacts scale down logic.
  # Now in Beta, and enabled by default
  priorities:
    - type: Counter # Sort by a “Counter”
      key: rooms # The name of the Counter. No impact if no GameServer found.
      order: Descending # Default is "Ascending" so smaller available capacity will be removed first on down scaling.
    - type: List # Sort by a “List”
      key: players # The name of the List. No impact if no GameServer found.
      order: Ascending # Default is "Ascending" so smaller available capacity will be removed first on down scaling.
  template:
    # GameServer metadata
    metadata:
      labels:
        foo: bar
    # GameServer specification
    spec:
      ports:
      - name: default
        portPolicy: Dynamic
        containerPort: 26000
      health:
        initialDelaySeconds: 30
        periodSeconds: 60
      # Parameters for game server sidecar
      sdkServer:
        logLevel: Info
        grpcPort: 9357
        httpPort: 9358
      #
      # [Stage:Beta]
      # [FeatureFlag:CountsAndLists]
      # Counts and Lists provides the configuration for generic (player, room, session, etc.) tracking features.
      # Now in Beta, and enabled by default
      counters:
        rooms:
          count: 0 # Initial value
          capacity: 10
      lists:
        players:
          values: []
      # The GameServer's Pod template
      template:
        spec:
          containers:
          - name: simple-game-server
            image: us-docker.pkg.dev/agones-images/examples/simple-game-server:0.40

Since Agones defines a new Custom Resources Definition (CRD) we can define a new resource using the kind Fleet with the custom group agones.dev and API version v1.

GameServer Health Checking

Thu, 03 Jan 2019 01:20:19 +0000

Disabling Health Checking

By default, health checking is enabled, but it can be turned off by setting the spec.health.disabled property to true.

SDK API

The Health() function on the SDK object needs to be called at an interval less than the spec.health.periodSeconds threshold time to be considered before it will be considered a failure.

The health check will also need to have not been called a consecutive number of times (spec.health.failureThreshold), giving it a chance to heal if it there is an issue.

C++ Game Server Client SDK

Wed, 02 Jan 2019 10:17:50 +0000

Check the Client SDK Documentation for more details on each of the SDK functions and how to run the SDK locally.

SDK Functionality

Area	Action	Implemented
Lifecycle	Ready	✔️
Lifecycle	Health	✔️
Lifecycle	Reserve	✔️
Lifecycle	Allocate	✔️
Lifecycle	Shutdown	✔️
Configuration	GameServer	✔️
Configuration	WatchGameServer	✔️
Metadata	SetAnnotation	✔️
Metadata	SetLabel	✔️
Counters	GetCounterCount	❌
Counters	SetCounterCount	❌
Counters	IncrementCounter	❌
Counters	DecrementCounter	❌
Counters	SetCounterCapacity	❌
Counters	GetCounterCapacity	❌
Lists	AppendListValue	❌
Lists	DeleteListValue	❌
Lists	SetListCapacity	❌
Lists	GetListCapacity	❌
Lists	ListContains	❌
Lists	GetListLength	❌
Lists	GetListValues	❌

Installation

Download

Download the source from the Releases Page or directly from GitHub .

Quickstart: Create a Game Server Fleet

Wed, 02 Jan 2019 06:42:20 +0000

Prerequisites

The following prerequisites are required to create a GameServer:

A Kubernetes cluster with the UDP port range 7000-8000 open on each node. Creating the firewall.
Agones controller installed in the targeted cluster
kubectl properly configured
Netcat which is already installed on most Linux/macOS distributions, for windows you can use WSL.

If you don’t have a Kubernetes cluster you can follow these instructions to create a cluster on Google Kubernetes Engine (GKE), Minikube or Azure Kubernetes Service (AKS), and install Agones.

Amazon Elastic Kubernetes Service

Mon, 01 Jan 0001 00:00:00 +0000

Create your EKS Cluster using the Getting Started Guide.

Possible steps are the following:

Create new IAM role for cluster management.
Run aws configure to authorize your awscli with proper AWS Access Key ID and AWS Secret Access Key.
Create an example cluster:

eksctl create cluster \
--name prod \
--version 1.35 \
--nodegroup-name standard-workers \
--node-type t3.medium \
--nodes 3 \
--nodes-min 3 \
--nodes-max 4

Allowing UDP Traffic

For Agones to work correctly, we need to allow UDP traffic to pass through to our EKS cluster worker nodes. To achieve this, we must update the workers’ nodepool SG (Security Group) with the proper rule. A simple way to do that is:

Installing Agones on Azure Kubernetes Service using Terraform

Mon, 01 Jan 0001 00:00:00 +0000

Installation

Install az utility by following these instructions.

The example of AKS submodule configuration could be found here: Terraform configuration with Agones submodule

Copy module.tf file into a separate folder.

az login

Configure your terraform:

terraform init

Create a service principal and configure its access to Azure resources:

az ad sp create-for-rbac

Now you can deploy your cluster (use values from the above command output):

terraform apply -var client_id="<appId>" -var client_secret="<password>"

Once you created all resources on AKS you can get the credentials so that you can use kubectl to configure your cluster:

Install Agones using Helm

Mon, 01 Jan 0001 00:00:00 +0000

Prerequisites

Helm package manager 3.2.3+
Supported Kubernetes Cluster

Helm 3

Installing the Chart

To install the chart with the release name my-release using our stable helm repository:

helm repo add agones https://agones.dev/chart/stable
helm repo update
helm install my-release --namespace agones-system --create-namespace agones/agones

We recommend installing Agones in its own namespaces, such as agones-system as shown above. If you want to use a different namespace, you can use the helm --namespace parameter to specify.

GameServer Counters and Lists

Mon, 08 Jan 2024 00:00:00 +0000

Warning

The Counters and Lists feature is currently Beta, and while it is enabled by default it may change in the future.

Use the Feature Gate CountsAndLists to disable this feature.

See the Feature Gate documentation for details on how to disable features.

Counters and Lists is provided as a way to track arbitrary integer counter values as well as lists of values against a GameServer by a user provided key.

Installing Agones on OCI Kubernetes Engine using Terraform

Mon, 21 Oct 2024 00:00:00 +0000

Installation

You can use Terraform to provision your OKE (Oracle Kubernetes Engine) cluster and install Agones on it using the Helm Terraform provider.

An example of the OKE submodule script files can be found here: Terraform configuration with Agones submodule

Copy these files into a separate folder.

Configure your OCI CLI tool CLI configure:

oci setup config

Initialise your terraform:

terraform init

Creating Cluster

By editing terraform.auto.tfvars you can change the parameters that you need to. For instance, the - kubernetes_version variable.

Canary Testing a new Fleet

Tue, 27 Jul 2021 23:49:14 +0000

To canary release/test a new Fleet, we can run a small, fixed size Fleet of the new version of our GameServer, while also running the current stable production version.

Allocations can then prefer to come from the canary Fleet, but if all GameServers are already allocated from the canary Fleet, players will be allocated to the current stable Fleets.

Over time, if the monitoring of those playing on the canary Fleet is working as expected, the size of the canary Fleet can be grown until you feel confident in its stability.

Player Tracking

Tue, 19 May 2020 00:00:00 +0000

Counters and Lists replaces the Alpha functionality of Player Tracking, and Player Tracking will soon be removed from Agones.

If you are currently using this Alpha feature, please plan on migrating to use Counters and Lists to ensure it meets all your needs.

Warning

The Player Tracking feature is currently Alpha, not enabled by default, and may change in the future.

Use the FeatureGate PlayerTracking to enable and test this feature.

GameServerAllocation Specification

Sun, 07 Jul 2019 03:58:52 +0000

Allocation is the process of selecting the optimal GameServer that matches the filters defined in the GameServerAllocation specification below, and returning its details.

A successful Alloction moves the GameServer to the Allocated state, which indicates that it is currently active, likely with players on it, and should not be removed until SDK.Shutdown() is called, or it is explicitly manually deleted.

A full GameServerAllocation specification is available below and in the example folder for reference:

Go Game Server Client SDK

Fri, 17 May 2019 10:17:50 +0000

Check the Client SDK Documentation for more details on each of the SDK functions and how to run the SDK locally.

SDK Functionality

Area	Action	Implemented
Lifecycle	Ready	✔️
Lifecycle	Health	✔️
Lifecycle	Reserve	✔️
Lifecycle	Allocate	✔️
Lifecycle	Shutdown	✔️
Configuration	GameServer	✔️
Configuration	Watch	✔️
Metadata	SetAnnotation	✔️
Metadata	SetLabel	✔️
Counters	GetCounterCount	✔️
Counters	SetCounterCount	✔️
Counters	IncrementCounter	✔️
Counters	DecrementCounter	✔️
Counters	SetCounterCapacity	✔️
Counters	GetCounterCapacity	✔️
Lists	AppendListValue	✔️
Lists	DeleteListValue	✔️
Lists	SetListCapacity	✔️
Lists	GetListCapacity	✔️
Lists	ListContains	✔️
Lists	GetListLength	✔️
Lists	GetListValues	✔️
Player Tracking	GetConnectedPlayers	✔️
Player Tracking	GetPlayerCapacity	✔️
Player Tracking	GetPlayerCount	✔️
Player Tracking	IsPlayerConnected	✔️
Player Tracking	PlayerConnect	✔️
Player Tracking	PlayerDisconnect	✔️
Player Tracking	SetPlayerCapacity	✔️

Installation

go get the source, directly from GitHub

Limiting CPU & Memory

Thu, 03 Jan 2019 05:45:15 +0000

As a short description:

CPU Requests are limits that are applied when there is CPU congestion, and as such can burst above their set limits.
CPU Limits are hard limits on how much CPU time the particular container gets access to.

This is useful for game servers, not just as a mechanism to distribute compute resources evenly, but also as a way to advice the Kubernetes scheduler how many game server processes it is able to fit into a given node in the cluster.

Fleet Autoscaler Specification

Thu, 03 Jan 2019 03:58:55 +0000

A full FleetAutoscaler specification is available below and in the example folder for reference, but here are several examples that show different autoscaling policies.

Ready Buffer Autoscaling

Fleet autoscaling with a buffer can be used to maintain a configured number of game server instances ready to serve players based on number of allocated instances in a Fleet. The buffer size can be specified as an absolute number or a percentage of the desired number of Ready game server instances over the Allocated count.

Quickstart: Create a Fleet Autoscaler

Wed, 02 Jan 2019 06:42:33 +0000

Prerequisites

It is assumed that you have followed the instructions to Create a Game Server Fleet and you have a running fleet of game servers.

Objectives

Create a Fleet Autoscaler in Kubernetes using Agones custom resource.
Watch the Fleet scale up when allocating GameServers
Watch the Fleet scale down when shutting down allocated GameServers
Edit the autoscaler specification to apply live changes

1. Create a Fleet Autoscaler

Let’s create a Fleet Autoscaler using the following command :

Azure Kubernetes Service

Mon, 01 Jan 0001 00:00:00 +0000

Choosing your shell

You can use either Azure Cloud Shell or install the Azure CLI on your local shell in order to install AKS in your own Azure subscription. Cloud Shell comes preinstalled with az and kubectl utilities whereas you need to install them locally if you want to use your local shell. If you use Windows 10, you can use the WIndows Subsystem for Windows as well.

Creating the AKS cluster

If you are using Azure CLI from your local shell, you need to log in to your Azure account by executing the az login command and following the login procedure.

Local Game Server

Tue, 19 Feb 2019 08:00:00 +0000

You can register a local game server with Agones. This means you can run an experimental build of your game server in the Agones environment without the need of packaging and deploying it to a fleet. This allows you to quickly iterate on your game server code while still being able to plugin to your Agones environment.

Register your server with Agones

To register your local game server you’ll need to know the IP address of the machine running it and the port. With that you’ll create a game server config like the one below.

Latency Testing with Multiple Clusters

Thu, 03 Jan 2019 01:20:30 +0000

To make latency testing easier, Agones installs with a simple ping service with both HTTP and UDP services that can be called for the purpose of timing how long the roundtrip takes for information to be returned from either of these services.

Installing

By default, Agones installs Kubernetes Services for both HTTP and the UDP ping endpoints. These can be disabled entirely, or disabled individually. See the Helm install guide for the parameters to pass through, as well as configuration options.

Quickstart: Create a Fleet Autoscaler with Webhook Policy

Wed, 02 Jan 2019 06:42:44 +0000

In some cases, your game servers may need to use custom logic for scaling your fleet that is more complex than what can be expressed using the Buffer policy in the fleetautoscaler. This guide shows how you can extend Agones with an autoscaler webhook to implement a custom autoscaling policy.

When you use an autoscaler webhook the logic computing the number of target replicas is delegated to an external HTTP/S endpoint, such as one provided by a Kubernetes deployment and service in the same cluster (as shown in the examples below). The fleetautoscaler will send a request to the webhook autoscaler’s /scale endpoint every sync period (currently 30s) with a JSON body, and scale the target fleet based on the data that is returned.

OCI Kubernetes Engine

Mon, 01 Jan 0001 00:00:00 +0000

Create your OKE Cluster using the Getting Started Guide.

Note

To create a cluster, you must either belong to the tenancy’s Administrators group, or belong to a group to which a policy grants the CLUSTER_MANAGE permission. See Policy Configuration for Cluster Creation and Deployment.

Possible steps to create OKE cluster through OCI web console are the following:

Open the navigation menu and click Developer Services. Under Containers & Artifacts, click Kubernetes Clusters (OKE).
Select the compartment in which you want to create the cluster.
On the Clusters page, click Create cluster.
Select one of the following workflows to create the cluster:
- Quick Create: Select this workflow when you only want to specify those properties that are absolutely essential for cluster creation. When you select this option, Kubernetes Engine uses default values for many cluster properties, and creates new network resources as required.
- Custom Create: Select this workflow when you want to be able to specify all of the cluster’s properties, use existing network resources, and select advanced options.
Click Submit.
Complete the pages of the workflow you selected. For more information, see:
- Using the Console to create a Cluster with Default Settings in the ‘Quick Create’ workflow
- Using the Console to create a Cluster with Explicitly Defined Settings in the ‘Custom Create’ workflow

Allowing UDP Traffic

For Agones to work correctly, we need to allow UDP traffic to pass through to our OKE cluster worker nodes. To achieve this, we must update the workers’ nodepool SG (Security Group) with the proper rule. A simple way to do that is:

Quickstart: Create a Fleet Autoscaler with Wasm

Tue, 09 Dec 2025 00:00:00 +0000

Warning

The Wasm Autoscaler feature is currently Alpha, not enabled by default, and may change in the future.

Use the FeatureGate WasmAutoscaler to enable and test this feature.

See the Feature Gate documentation for details on how to enable features.

In some cases, your game servers may need to use custom logic for scaling your fleet that is more complex than what can be expressed using the Buffer policy in the fleetautoscaler. This guide shows how you can extend Agones with a WebAssembly (Wasm) autoscaler to implement a custom autoscaling policy.

Reusing Allocated GameServers for more than one game session

Wed, 01 Sep 2021 00:00:00 +0000

Having a GameServer terminate after a single player session is better for packing and optimisation of infrastructure usage, as well as safety to ensure the process returns to an absolute zero state.

However, depending on the GameServer startup time, or other factors there may be reasons you wish to reuse a GameServer for n number of sessions before finally shutting it down.

The “magic trick” to this is knowing that the GameServer process can call SDK.Ready() to return to a Ready state after the GameServer has been allocated.

C# Game Server Client SDK

Thu, 28 May 2020 00:00:00 +0000

Check the Client SDK Documentation for more details on each of the SDK functions and how to run the SDK locally.

SDK Functionality

Area	Action	Implemented
Lifecycle	Ready	✔️
Lifecycle	Health	✔️
Lifecycle	Reserve	✔️
Lifecycle	Allocate	✔️
Lifecycle	Shutdown	✔️
Configuration	GetGameServer	✔️
Configuration	WatchGameServer	✔️
Metadata	SetAnnotation	✔️
Metadata	SetLabel	✔️
Counters	GetCounterCount	✔️
Counters	SetCounterCount	✔️
Counters	IncrementCounter	✔️
Counters	DecrementCounter	✔️
Counters	SetCounterCapacity	✔️
Counters	GetCounterCapacity	✔️
Lists	AppendListValue	✔️
Lists	DeleteListValue	✔️
Lists	SetListCapacity	✔️
Lists	GetListCapacity	✔️
Lists	ListContains	✔️
Lists	GetListLength	✔️
Lists	GetListValues	✔️
Player Tracking	GetConnectedPlayers	✔️
Player Tracking	GetPlayerCapacity	✔️
Player Tracking	GetPlayerCount	✔️
Player Tracking	IsPlayerConnected	✔️
Player Tracking	PlayerConnect	✔️
Player Tracking	PlayerDisconnect	✔️
Player Tracking	SetPlayerCapacity	✔️

Download

Download the source directly from GitHub .

Node.js Game Server Client SDK

Mon, 01 Apr 2019 00:00:00 +0000

Check the Client SDK Documentation for more details on each of the SDK functions and how to run the SDK locally.

SDK Functionality

Area	Action	Implemented
Lifecycle	Ready	✔️
Lifecycle	Health	✔️
Lifecycle	Reserve	✔️
Lifecycle	Allocate	✔️
Lifecycle	Shutdown	✔️
Configuration	GetGameServer	✔️
Configuration	WatchGameServer	✔️
Metadata	SetAnnotation	✔️
Metadata	SetLabel	✔️
Counters	GetCounterCount	✔️
Counters	SetCounterCount	✔️
Counters	IncrementCounter	✔️
Counters	DecrementCounter	✔️
Counters	SetCounterCapacity	✔️
Counters	GetCounterCapacity	✔️
Lists	AppendListValue	✔️
Lists	DeleteListValue	✔️
Lists	SetListCapacity	✔️
Lists	GetListCapacity	✔️
Lists	ListContains	✔️
Lists	GetListLength	✔️
Lists	GetListValues	✔️
Player Tracking	GetConnectedPlayers	✔️
Player Tracking	GetPlayerCapacity	✔️
Player Tracking	GetPlayerCount	✔️
Player Tracking	IsPlayerConnected	✔️
Player Tracking	PlayerConnect	✔️
Player Tracking	PlayerDisconnect	✔️
Player Tracking	SetPlayerCapacity	✔️

Prerequisites

Node.js >= 10.13.0

Usage

Add the agones dependency to your project:

Metrics

Thu, 03 Jan 2019 03:58:19 +0000

Agones controller exposes metrics via OpenCensus. OpenCensus is a single distribution of libraries that collect metrics and distributed traces from your services, we only use it for metrics but it will allow us to support multiple exporters in the future.

We choose to start with Prometheus as this is the most popular with Kubernetes but it is also compatible with Cloud Monitoring. If you need another exporter, check the list of supported exporters. It should be pretty straightforward to register a new one. (GitHub PRs are more than welcome.)

Access Agones via the Kubernetes API

Thu, 03 Jan 2019 01:20:41 +0000

Installing Agones creates several Custom Resource Definitions (CRD), which can be accessed and manipulated through the Kubernetes API.

The detailed list of Agones CRDs with their parameters could be found here - Agones CRD API Reference.

Kubernetes has multiple client libraries, however, at time of writing, only the Go and Python clients are documented to support accessing CRDs.

This can be found in the Accessing a custom resource section of the Kubernetes documentation.

At this time, we recommend interacting with Agones through the Go client that has been generated in this repository, but other methods may also work as well.

Rust Game Server Client SDK

Wed, 02 Jan 2019 10:17:57 +0000

Check the Client SDK Documentation for more details on each of the SDK functions and how to run the SDK locally.

SDK Functionality

Area	Action	Implemented
Lifecycle	Ready	✔️
Lifecycle	Health	✔️
Lifecycle	Reserve	✔️
Lifecycle	Allocate	✔️
Lifecycle	Shutdown	✔️
Configuration	GameServer	✔️
Configuration	Watch	✔️
Metadata	SetAnnotation	✔️
Metadata	SetLabel	✔️
Counters	GetCounterCount	✔️
Counters	SetCounterCount	✔️
Counters	IncrementCounter	✔️
Counters	DecrementCounter	✔️
Counters	SetCounterCapacity	✔️
Counters	GetCounterCapacity	✔️
Lists	AppendListValue	✔️
Lists	DeleteListValue	✔️
Lists	SetListCapacity	✔️
Lists	GetListCapacity	✔️
Lists	ListContains	✔️
Lists	GetListLength	✔️
Lists	GetListValues	✔️
Player Tracking	GetConnectedPlayers	✔️
Player Tracking	GetPlayerCapacity	✔️
Player Tracking	GetPlayerCount	✔️
Player Tracking	IsPlayerConnected	✔️
Player Tracking	PlayerConnect	✔️
Player Tracking	PlayerDisconnect	✔️
Player Tracking	SetPlayerCapacity	✔️

Prerequisites

Rust >= 1.50

Usage

Add this crate to dependencies section in your Cargo.toml.

High Density GameServers

Tue, 31 Aug 2021 00:00:00 +0000

Depending on the setup and resource requirements of your game server process, sometimes it can be a more economical use of resources to run multiple concurrent game sessions from within a single GameServer instance.

The tradeoff here is that this requires more management on behalf of the integrated game server process and external systems, since it works around the common Kubernetes and/or Agones container lifecycle.

Here are two different approaches to solving this problem with Agones:

Third Party Examples

Thu, 09 Sep 2021 00:00:00 +0000

Integrations with other projects

Octops/Agones x Open Match - How to implement a matchmaking system using Agones and Open Match
Agones x Godot - How to deploy a multiplayer Godot game with Agones. This post demonstrates hosting a simple multiplayer game server on Agones, utilizing the Agones Community SDK for Godot to manage server readiness and health checks. It also provides a brief introduction to dedicated game servers.
Unity’s Netcode for GameObjects + Agones - A simple Unity example that demonstrates Agones integrations with Unity’s Netcode for GameObjects for dedicated game servers.

Minetest

Minetest is a free and open-source sandbox video game available for Linux, FreeBSD, Microsoft Windows, MacOS, and Android. Minetest game play is very similar to that of Minecraft. Players explore a blocky 3D world, discover and extract raw materials, craft tools and items, and build structures and landscapes.
Minetest server for Agones is an example of the Minetest server hosted on Kubernetes using Agones. It wraps the Minetest server with a Go binary, and introspects stdout to provide the event hooks for the SDK integration. The wrapper is from Xonotic Example with a few changes to look for the Minetest ready output message.

You will need to download the Minetest client separately to play.

Allocating based on GameServer Player Capacity

Tue, 31 Aug 2021 00:00:00 +0000

Using this approach, we are able to be able to make an Allocation request that is akin to: “Find me a GameServer that is already allocated, with room for n number of players, and if one is not available, allocate me a Ready GameServer”.

Common applications of this type of allocation are Lobby servers where players await matchmaking, or a persistent world server where players connect and disconnect from a large map.

Third Party Libraries and Tools

Fri, 15 May 2020 00:00:00 +0000

Client SDKs

Cubxity/AgonesKt - Agones Client SDK for Kotlin
scrayosnet/agones-kotlin-sdk - Agones Client SDK for Kotlin
AndreMicheletti/godot-agones-sdk - Agones Client SDK for Godot Engine
Infumia/agones4j - Agones Client SDK for Java
Devsisters/zio-agones - Agones Client SDK for Scala

Messaging

Libraries or applications that implement messaging systems.

Octops/Agones Event Broadcaster - Broadcast Agones events to the external world
Octops/Agones Broadcaster HTTP - Expose Agones GameServers information via HTTP
Octops/Agones Relay HTTP - Publish Agones GameServers and Fleets details to HTTP endpoints

Controllers

Octops/Game Server Ingress Controller - Automatic Ingress configuration for Game Servers managed by Agones
Octops/Image Syncer - Watch Fleets and pre-pull images of game servers on every node running in the cluster
Octops/Fleet Garbage Collector - Delete Fleets based on its TTL

Allocation

agones-allocator-client - A client for testing allocation servers. Made by Fairwinds
Multi-cluster allocation demo - A demo project for multi-cluster allocation on Amazon EKS with Terraform templates.

Development Tools

Minikube Agones Cluster - Automates the creation of a complete Kubernetes/Agones Cluster locally, using Xonotic as a sample gameserver. Intended to provide a local environment for developers which approximates a production Agones deployment.

Agones Guru on Gurubase

You can Ask Agones Guru for help. It is an Agones-focused AI designed to answer your questions.

Confirming Agones Installation

Mon, 01 Jan 0001 00:00:00 +0000

To confirm Agones is up and running, run the following command:

kubectl describe --namespace agones-system pods

It should describe six pods created in the agones-system namespace, with no error messages or status. All Conditions sections should look like this:

Conditions:
  Type              Status
  Initialized       True
  Ready             True
  ContainersReady   True
  PodScheduled      True

All this pods should be in a RUNNING state:

kubectl get pods --namespace agones-system

NAME                                 READY   STATUS    RESTARTS   AGE
agones-allocator-5c988b7b8d-cgtbs    1/1     Running   0          8m47s
agones-allocator-5c988b7b8d-hhhr5    1/1     Running   0          8m47s
agones-allocator-5c988b7b8d-pv577    1/1     Running   0          8m47s
agones-controller-7db45966db-56l66   1/1     Running   0          8m44s
agones-ping-84c64f6c9d-bdlzh         1/1     Running   0          8m37s
agones-ping-84c64f6c9d-sjgzz         1/1     Running   0          8m47s

That’s it!

Upgrading Agones and Kubernetes

Fri, 16 Aug 2019 00:19:19 +0000

Note

Whichever approach you take to upgrading Agones, make sure to test it in your development environment before applying it to production.

Upgrading Agones

The following are strategies for safely upgrading Agones from one version to another. They may require adjustment to your particular game architecture but should provide a solid foundation for updating Agones safely.

The recommended approach is to use multiple clusters, such that the upgrade can be tested gradually with production load and easily rolled back if the need arises.

REST Game Server Client API

Wed, 02 Jan 2019 10:18:08 +0000

Check the Client SDK Documentation for more details on each of the SDK functions and how to run the SDK locally.

SDK Functionality

Area	Action	Implemented
Lifecycle	Ready	✔️
Lifecycle	Health	✔️
Lifecycle	Reserve	✔️
Lifecycle	Allocate	✔️
Lifecycle	Shutdown	✔️
Configuration	GetGameServer	✔️
Configuration	WatchGameServer	✔️
Metadata	SetAnnotation	✔️
Metadata	SetLabel	✔️
Counters	GetCounter	✔️
Counters	UpdateCounter	✔️
Lists	GetList	✔️
Lists	UpdateList	✔️
Lists	AddListValue	✔️
Lists	RemoveListValue	✔️
Player Tracking	GetPlayerCapacity	✔️
Player Tracking	SetPlayerCapacity	✔️
Player Tracking	PlayerConnect	✔️
Player Tracking	GetConnectedPlayers	✔️
Player Tracking	IsPlayerConnected	✔️
Player Tracking	GetPlayerCount	✔️
Player Tracking	PlayerDisconnect	✔️

The REST API can be accessed from http://localhost:${AGONES_SDK_HTTP_PORT}/ from the game server process. AGONES_SDK_HTTP_PORT is an environment variable automatically set for the game server process by Agones to support binding the REST API to a dynamic port. It is advised to use the environment variable rather than a hard coded port; otherwise your game server will not be able to contact the SDK server if it is configured to use a non-default port.

Minikube

Mon, 01 Jan 0001 00:00:00 +0000

Installing Minikube

First, install Minikube, which may also require you to install a virtualisation solution, such as VirtualBox as well.

Starting Minikube

Minikube will need to be started with the supported version of Kubernetes that is supported with Agones, via the --kubernetes-version command line flag.

Optionally, we also recommend starting with an agones profile, using -p to keep this cluster separate from any other clusters you may have running with Minikube.

minikube start --kubernetes-version v1.34.6 -p agones

For testing scenarios that require multiple nodes, you can add the --nodes parameter to create a multi-node cluster.

Troubleshooting

Thu, 03 Jan 2019 01:20:49 +0000

Something went wrong with my GameServer

If there is something going wrong with your GameServer, there are a few approaches to determining the cause:

Run with the local SDK server

A good first step for seeing what may be going wrong is replicating the issue locally. To do this you can take advantage of the Agones local SDK server , with the following troubleshooting steps:

Run your game server as a local binary against the local SDK server
Run your game server container against the local SDK server. It’s worth noting that running with docker run --network=host ... can be an easy way to allow your game server container(s) access to the local SDK server)

At each stage, keep an eye on the logs of your game server binary, and the local SDK server, and ensure there are no system errors.

Out of Cluster Dev Server

Tue, 15 Aug 2023 07:00:00 +0000

This section builds upon the topics discussed in local SDK Server, Local Game Server, and GameServer allocation (discussed here, here, and here). Having a firm understanding of those concepts will be necessary for running an “out of cluster” local server.

Running an “out of cluster” dev server combines the best parts of local debugging and being a part of a cluster. A developer will be able to run a custom server binary on their local machine, even within an IDE with breakpoints. The server would also be allocatable within a cluster, allowing integration with the project’s full stack for handling game server lifetime.

Local Development

Tue, 29 Jan 2019 10:18:08 +0000

When the game server is running on Agones, the SDK communicates over TCP to a small gRPC server that Agones coordinated to run in a container in the same network namespace as it - usually referred to in Kubernetes terms as a “sidecar”.

Therefore, when developing locally, we also need a process for the SDK to connect to!

To do this, we can run the same binary (the SDK Server) that runs inside Agones, but pass in a flag to run it in “local mode”. Local mode means that the sidecar binary will not try to connect to anything, and will just send log messages to stdout and persist local state in memory so that you can see exactly what the SDK in your game server is doing, and can confirm everything works.

Agones Feature Proposal (AFP)

Mon, 01 Jan 0001 00:00:00 +0000

Overview of the Agones Feature Proposal (AFP) Process

The Agones Feature Proposal (AFP) process provides a standardized way to propose, discuss, and track new features, enhancements, or architectural changes within the Agones project. This process is intended to ensure clarity, transparency, and collaborative decision-making, allowing stakeholders to effectively contribute to and communicate about important changes in the project.

Key Objectives of the AFP Process

Standardized Proposals: Offers a common structure for proposing changes, ensuring that the motivation for a feature, its implementation, and its impact are clearly defined.
Cross-Team Communication: Facilitates collaboration across different teams within the Agones community, ensuring that all relevant stakeholders are informed and involved in the decision-making process.
Roadmap Integration: Supports the creation of a user-facing development roadmap that outlines upcoming features and changes.
Feature Tracking: Allows features and major changes to be tracked across one or more releases, providing a historical record of decisions and progress.

AFP Structure

Each AFP consists of several key sections that are defined incrementally as the feature progresses. These sections typically include:

Documentation Editing and Contribution

Mon, 01 Jan 0001 00:00:00 +0000

Writing Documentation

We welcome contributions to documentation!

Running the site

If you clone the repository and run make site-server from the build directory, this will run the live hugo server, running as a showing the next version’s content and upcoming publishedDate’d content as well. This is likely to be the next releases’ version of the website.

To show the current website’s view, run it as make site-server ENV=RELEASE_VERSION=1.57.0 ARGS=

Platform

This site and documentation is built with a combination of Hugo, static site generator, with the Docsy theme for open source documentation.

1.56.0 - SidecarContainers in Beta, Hugo Upgrade & Site Dark Mode Enabled and More!

Tue, 24 Feb 2026 00:00:00 +0000

This is the 1.56.0 release of Agones

This release improves stability and usability with several key updates. The SidecarContainers feature is now in Beta. We have upgraded Hugo and Docsy, and dark mode has been enabled on the site. Node SDK linting has been migrated from ESLint to Biome. A Google Doodle containerized games case study has been added to third-party content. Additionally, an optional agones.metrics.serviceMonitor.additionalLabels map has been added to the Helm chart.

1.55.0 - FleetAutoscaleRequestMetaData in Beta, Go 1.25.0 and Debian 13 Base Images Upgrade and Remote Debugging in Minikube and More!

Tue, 13 Jan 2026 00:00:00 +0000

This is the 1.55.0 release of Agones

This release improves stability and usability with several key updates. The FleetAutoscaleRequestMetaData feature is now in Beta, allowing the webhook autoscaler to send fleet metadata (such as names, labels, and annotations) with scaling requests. We’ve upgraded to Go 1.25.0 and updated related dependencies and Dockerfiles. The hardcoded SdkServer update list limit has been replaced with a configurable gameservers.lists.maxItems option. New Minikube remote debugging support enables local debugging of the SDK and controller via improved port-forwarding.

1.54.0 - Kubernetes v1.34 Support, GKE Autopilot Passthrough Port, Simplified Autoscaling, Init Container Fixes, and New Counter State Tools.

Tue, 02 Dec 2025 00:00:00 +0000

This is the 1.54.0 release of Agones.

Agones now supports Kubernetes 1.32,1.33,1.34 and introduces a new Counter feature that improves state management and visibility in the GameServer resource, along with a fix for a related update issue. Autoscaler configuration is easier thanks to removing the caBundle requirement for standard HTTPS endpoints. A major bug affecting missing Agones SDK environment variables in Init Containers has been resolved. This release graduates AutopilotPassthroughPort to Stable, enabling direct node-to-GameServer communication on GKE Autopilot

1.53.0 - Rust Counters and Lists SDK,Container Startup Guarantees, and More!

Tue, 21 Oct 2025 00:00:00 +0000

This is the 1.53.0 release of Agones.

This release introduces a beta Rust SDK and lays the groundwork for WebAssembly (Wasm) Fleet Autoscaling with a new policy type and architectural refactoring. It also includes key bug fixes for List value removal and SDK initialization. The critical WebSocket connectivity fix, which was previously backported to the v1.52.2 patch release, is also included in this release.

Rust SDK (Beta) Counters and Lists Integration: Added initial implementation for the Rust SDK, integrating its beta features, including the Counter and List state management functionalities. This change also introduces unit tests for the Rust SDK and new conformance tests to ensure proper behavior within the Agones system.

1.52.0 - Helm and Kubectl Updates, Configurable GameServer Limits, Golang Upgrade, and More!

Tue, 09 Sep 2025 00:00:00 +0000

This is the 1.52.0 release of Agones

In this release, several improvements have been made to testing and error reporting, including new webhook autoscaler e2e tests and updated error fields in processor proto. Helm support has been enhanced with new strategy options, additional permissions for uninstall, and full test coverage on the latest Helm version. The kubectl image has been updated to a lighter alpine-based build for efficiency, and the hardcoded GameServer list limit has been replaced with a configurable gameservers.lists.maxItems option. Finally, Golang has been upgraded to 1.24.6, along with related dependencies, bringing performance, stability, and security improvements.

1.51.0 - ScheduledAutoscaler Beta, Sidecar Improvements, Unreal SDK Enhancements, and More!

Tue, 29 Jul 2025 00:00:00 +0000

This is the 1.51.0 release of Agones.

In this release, the ScheduledAutoscaler feature has been promoted to Beta, enhancing autoscaling with scheduled policy support. Several bug fixes improve system stability, including retry logic in addMoreGameServers and better handling of succeeded Pods. The Unreal SDK now supports list data structures, offering greater flexibility for game developers. Sidecar rate limiting has been updated to a constant interval for more predictable behavior. Monitoring and debugging have also been improved through Prometheus metrics tests and enhanced logging in upgrade workflows.

1.50.0 - RollingUpdateFix Beta, Go 1.24.4 Upgrade, Kubernetes v1.33 Support, and More!

Tue, 17 Jun 2025 00:00:00 +0000

This is the 1.50.0 release of Agones.

In this release, we’ve added important updates to improve stability and usability. The RollingUpdateFix feature is now in Beta, making Fleet updates more reliable. Agones now supports Kubernetes versions 1.31, 1.32, and 1.33. We’ve upgraded to Go 1.24.4 and updated related dependencies and Dockerfiles. Prometheus metrics testing and improved logging, including Chain ID tracking in FleetAutoscaler events, make monitoring and debugging easier. You can also now push Helm charts to custom registries.

1.49.0 - Beta support for PortPolicyNone, sidecar container support, AFP process update and more!

Tue, 06 May 2025 00:00:00 +0000

This is the 1.49.0 release of Agones.

In this release, we’ve made significant progress with several features. Key updates include promoting Port Policy to Beta, promoting the Disable Resync on SDK Server feature to stable, promoting the Port Ranges feature to Beta, enhancing the Agones Feature Proposal (AFP) process with new additions, and improving the GameServer life cycle with Sidecar Containers support.

Promote Port Policy None to Beta: The PortPolicyNone feature has progressed to beta in this release and is now enabled by default.

1.48.0 - Kubernetes 1.32 Support, dual-stack networking support, bug fixes and more!

Tue, 25 Mar 2025 00:00:00 +0000

This is the 1.48.0 release of Agones.

In this release, we’ve added support for new Kubernetes versions, improved Docker Buildx support for ARM64 and Windows, better Helm schema validation, dual-stack networking for load balancers, and the inclusion of fleet metadata in the Webhook Autoscaler for more accurate fleet size calculations.

Updated Kubernetes Version Support (v1.30, v1.31, v1.32): Agones now officially supports Kubernetes versions 1.30, 1.31, and 1.32, ensuring compatibility with the latest Kubernetes releases for improved performance and stability.

1.47.0 - Player Tracking with Lists, High Density Counters Documentation, Helm Schema Validation and More

Tue, 11 Feb 2025 00:00:00 +0000

This is the 1.47.0 release of Agones.

In this release, we’ve updated our Player Tracking guide to use Lists, added documentation on High Density Integration for Counters, and enhanced Helm support with JSON schema validation. Additionally, we’ve introduced the ability to change the externalTrafficPolicy for agones-ping services. Along with that, various documentation updates have been made to help users implement these features more easily.

Updated Player Tracking Guide to Use Lists: The Player Tracking Guide has been updated to use Lists, replacing the older Player Tracking functionality. This change provides a more flexible and scalable approach to managing player data in game servers.

1.46.0 - Go v1.23.4, Custom Labels, List Deletion, In-Place Upgrades in Alpha and More

Thu, 02 Jan 2025 00:00:00 +0000

This is the 1.46.0 release of Agones.

In this release, we’ve introduced Go v1.23.4 for improved performance, added support for custom labels on pods for enhanced monitoring, and enabled the deletion of list values during game server allocation. The externalTrafficPolicy for agones-allocator is now set to “Local” for stable allocations during node pool scaling. Additionally, the documentation has been updated with step-by-step instructions for in-place Agones upgrades.

Updated Versions: Go v1.23.4 Now Live: We have upgraded to Go v1.22.6 which brings enhanced performance and crucial security updates.

1.45.0 - Kubernetes 1.31 Support, OKE Cluster Setup Documentation, bug fixes and more

Tue, 19 Nov 2024 00:00:00 +0000

This is the 1.45.0 release of Agones.

In this release, we’ve introduced Terraform scripts and updated documentation for setting up Agones on Oracle Kubernetes Engine (OKE). Additionally, we’ve improved support for new Kubernetes versions, enhanced the Fleet Autoscaler, and introduced a new dashboard feature for GameServer state durations. Additionally, we’ve updated the Rust SDK and added a CI check for versioning in examples.

Updated Kubernetes Version Support (v1.29, v1.30, v1.31): Agones now officially supports Kubernetes versions 1.29, 1.30, and 1.31, ensuring compatibility with the latest Kubernetes releases for improved performance and stability.

1.44.0 - Beta support for Extended Duration Pods, Documentation Enhancements and version updates

Tue, 08 Oct 2024 00:00:00 +0000

This is the 1.44.0 release of Agones.

In this release, we have added beta support for Extended Duration Pods on GKE Autopilot, improved the Minikube documentation for running Agones, and updated the Helm and Fleet Autoscaler documentation. Additionally, we’ve upgraded the versions of Go and gRPC for improved performance and security.

Beta Support for Extended Duration Pods on GKE Autopilot: The GKEAutopilotExtendedDuration feature has progressed to beta in this release and is now enabled by default.

1.43.0 - Kubernertes 1.30 Support, Scheduled Fleet Autoscaler and many more new features!

Tue, 27 Aug 2024 00:00:00 +0000

This is the 1.43.0 release of Agones.

In this release, we updated the supported Kubernetes version, added a new scheduled autoscaler, as well as Unity support for Counters and Lists..

Kubernetes 1.30 Support With this release, the Kubernetes support matrix for Agones is now 1.28, 1.29 and 1.30.
Alpha support for ScheduledAutoscaler This provides the ability to have Fleet autoscaler scheduling with the feature flag ScheduledAutoscaler, to allow you to schedule what level of autoscaling you would like on a schedule or between dates, giving you more control over your autoscaling needs.

1.42.0 - Added Kubernetes Security contexts, bug fixes and more!

Tue, 16 Jul 2024 00:00:00 +0000

This is the 1.42.0 release of Agones.

In this release we’ve added support for Kubernetes Security Contexts for all Agones containers, updated our documentation, and moved work forward on In-place Agones Upgrades and Scheduled Autoscalers.

Note: In this release we also removed the ConnectAsync method from the C# SDK, since it wasn’t providing any functionality for several releases. There’s no need to upgrade SDK’s at this time, but be aware that if you do, this function call will need to be removed from your code.

1.41.0 - Counters And Lists Beta Release, New PortPolicy and Multiple Feature Added!

Tue, 04 Jun 2024 00:00:00 +0000

This is the 1.41.0 release of Agones.

In this release, we’ve graduated the Counters and Lists feature to Beta, added a new None PortPolicy in Gameserver if you only want in-cluster communications, and started work on in-place upgrades of Agones – starting with providing SDK compatibility guarantees between versions. . Additionally, we now have Alpha support for the Passthrough PortPolicy on GKE Autopilot.

Graduate Counters and Lists to Beta: We’ve graduated the Counters and Lists Feature from Alpha to Beta, which also includes a new Counters and Lists documentation landing page.

1.40.0 - Kubernetes 1.29.0, CSharp SDK for Counters and Lists, and Multiple Feature Promotions

Tue, 23 Apr 2024 00:00:00 +0000

This is the 1.40.0 release of Agones.

In this release, we’ve updated our Kuberenetes support to include version 1.29, introduced a new implementation in the CSharp SDK for the Counters and Lists, graduated the FleetAllocationOverflow feature to stable, moved the DisableResyncOnSDKServer feature into beta and refined the documentation for Counters and Lists to simplify usage and enhance clarity.

Kubernetes Support Update 1.29: We’ve upgraded our Kubernetes compatibility to include version 1.29 and have discontinued support for version 1.26. Our current supported versions are now 1.27, 1.28, and 1.29. Please ensure your clusters are upgraded to one of these supported versions.

1.39.0 - New GenAI and Custom Controller Examples and Counters and Lists Values Available on Allocation Constraints

Tue, 12 Mar 2024 00:00:00 +0000

This is the 1.39.0 release of Agones.

In this release, we’ve made some important changes and introduced exciting new features, including an example for integrating GenAI, improved GameServer allocation results for Counters and Lists, and a new example custom GameServer controller.

Breaking Changes:

C++ gRPC Setup: This is a breaking change with our dependency management for C++ and gRPC. Our CMake file no longer automatically imports and compiles gRPC, as it was getting increasingly fragile. Now, to install the C++ SDK, you will need to install gRPC manually before installing the C++ SDK.

1.38.0 - Improved Counters and Lists, Nodepool Upgrades on GKE Terraform, and Pod support for Topology Spread Constraints

Tue, 30 Jan 2024 00:00:00 +0000

This is the 1.38.0 release of Agones.

Key highlights of this release include Nodepool Upgrades on GKE Terraform and the support of Pod Topology Spread Constraints, alongside internal upgrades to Golang, Docker, and Debian. We have also made improvements to the Agones documentation, particularly for the Counters and Lists feature.

Improved Counters and Lists: New life cycle management examples in the Agones documentation are now available for the Counters and Lists feature. Try it out, share your feedback, and if you find any bugs, please file issues and PRs.

1.37.0 - Counters And Lists Alpha Release and Multiple Feature Promotions!

Tue, 19 Dec 2023 00:00:00 +0000

This is the 1.37.0 release of Agones.

This release sees the first milestone of a over-a-year series of work on the functionality of arbitrary Counters and Lists attached to each GameServer!

We’ve also upgraded the following features: CountsAndLists to alpha, FleetAllocationOverflow to Beta, and PodHostName, ResetMetricsOnDelete, and SplitControllerAndExtensions to Stable - with defaults below.

CountsAndLists: This feature flag provides functionality for a configurable set of Counters or Lists be attached to GameServers with attached allocation and autoscaling functionality to provide a flexible implementation that can handle a wide range of use cases such as player tracking, high density game server room tracking, and could even be used for game specific game server allocation prioritization.

1.36.0 - Kubernetes 1.28, Unreal Engine Plugin Fix, and Lots of Security Fixes

Tue, 07 Nov 2023 00:00:00 +0000

This is the 1.36.0 release of Agones.

In this release:

We’ve added support for Kubernetes 1.28 and have discontinued support for 1.25 to bring the support matrix to 1.26, 1.27 and 1.28 . Please upgrade your clusters accordingly.
We’ve resolved path issues in the Unreal Engine Plugin to ensure compatibility with Unreal Engine 5.3.
We are now using Go 1.20.10 and gRPC 1.57.1, which includes a number of performance improvements and important security fixes.
GameServers that end up in Error state now have a delay before deletion, allowing developers a chance to see why they have failed, and prevent GameServer churn from overwhelming the Kubernetes control plane.
We’ve upgraded to the latest v0.7.1 Docsy- let us know if you see anything broken in the docs!

Check the README for details on features, installation and usage.

1.35.0 - Improved Memory Usage, SDK Server Enhancements, Component Upgrades

Tue, 26 Sep 2023 00:00:00 +0000

This is the 1.35.0 release of Agones.

In this release, we’ve improved our internal development toolchain, refined the memory usage of GameServer sub-controllers, and updated essential components including grpc-gateway and Hugo.

Memory Usage Improvement: Increased the number of workers for sub-controllers of the GameServer controller to match other controllers, leading to a much more stable memory footprint for the controller as events don’t get backed up in the worker queues.

1.34.0 - Kubernetes 1.27 Support, Allocation State Filter to Stable, and all the Addresses for GameServers

Tue, 15 Aug 2023 00:00:00 +0000

This is the 1.34.0 release of Agones.

In this release, we’ve upgraded Kubernetes compatibility, graduated StateAllocationFilter to stable, and enhanced GameServers and GameServerAllocation address support.

Kubernetes Support: The latest update extends support to Kubernetes versions 1.25, 1.26, and 1.27, enhancing compatibility with current Kubernetes deployments.
Allocation State Filter is now Stable: The allocation state filter feature has been promoted to stable. It determines the specific state that should be filtered when trying to obtain a GameServer through allocation. By default, this filter is set to Ready, but it can also be set to Allocated. When the Allocated option is selected, it can be combined with label or player selectors to access an already Allocated GameServer.

1.33.0 - SDKGracefulTermination To Stable and Returning Metadata on Allocation

Wed, 05 Jul 2023 00:00:00 +0000

This is the 1.33.0 release of Agones.

In this release, we have focused on improving the documentation, stabilized the SDKGracefulTermination feature, and are now returning GameServer annotations and labels on allocation response.

The SDKGracefulTermination feature has been promoted to stable. The SDK server will now remain active for the specified terminationGracePeriodSeconds until SDK.Shutdown() has been called to ensure that game servers can successfully run to completion during automatic node upgrades without downtime.

1.32.0 - Go 1.20 and Many Features Graduated To Beta!

Tue, 23 May 2023 00:00:00 +0000

This is the 1.32.0 release of Agones.

This upgrade ensures that your game servers are equipped with the latest tools and improvements, enhancing their overall performance and stability:

Upgrade to Go version 1.20.
The ResetMetricsOnDelete feature is now beta and enabled by default. Now when a Fleet or FleetAutoscaler is deleted from the system, Agones will automatically clear metrics that utilize their name as a label from the exported metrics, so the metrics exported do not continuously grow in size over the lifecycle of the Agones installation.
The PodHostname feature that allows you to access a GameServer Pod within a cluster by a DNS name is now beta and enabled by default.
The SplitControllerAndExtensions feature which splits the Agones controller into multiple binaries for better reliability is now beta and enabled by default.
The SafeToEvict feature has been promoted to stable.

We encourage you to take advantage of these promoted features to enhance the stability, performance, and functionality of your game servers.

Google Kubernetes Engine Best Practices

Fri, 12 May 2023 00:00:00 +0000

Overview

On this page, we’ve collected several Google Kubernetes Engine (GKE) best practices.

Release Channels

Why?

We recommend using Release Channels for all GKE clusters. Using Release Channels has several advantages:

Google automatically manages the version and upgrade cadence for your Kubernetes Control Plane and its nodes.
Clusters on a Release Channel are allowed to use the No minor upgrades and No minor or node upgrades scope of maintenance exclusions - in other words, enrolling a cluster in a Release Channel gives you more control over node upgrades.
Clusters enrolled in rapid channel have access to the newest Kubernetes version first. Agones strives to support the newest release in rapid channel to allow you to test the newest Kubernetes soon after it’s available in GKE.

Note

GKE Autopilot clusters must be on Release Channels.

1.31.0 - Fixes for Health Checking, Updated Kubernetes Version and Lots of Improvements!

Tue, 11 Apr 2023 00:00:00 +0000

This is the 1.31.0 release of Agones.

In this release we see fixes that ensure that GameServers won’t move to Unhealthy while they are still downloading their images, Kubernetes versions 1.24, 1.25 and 1.26 are now supported, as well as a bunch of other smaller bug fixes and project improvements.

Check the README for details on features, installation and usage.

Breaking changes:

Update Supported Kubernetes to 1.24 1.25 1.26 by @gongmax in https://github.com/agones-dev/agones/pull/3029

Implemented enhancements:

1.30.0 - GKE Autopilot and Multiple Kubernetes version support

Tue, 28 Feb 2023 00:00:00 +0000

This is the 1.30.0 release of Agones.

This release brings us support for multiple Kubernetes versions (no more being tied to a single version!), support for GKE Autopilot, and a large collection of bug fixes and general improvements. This is also the first release following our new release process whereby we do not publish a release candidate prior to the release.

Check the README for details on features, installation and usage.

1.29.0 - Kubernetes 1.24.0, SDKGracefulTermination feature in beta, New PodHostname feature

Tue, 17 Jan 2023 00:00:00 +0000

This is the 1.29.0 release of Agones.

We are bringing a huge release to start 2023!

Update Agones to support for Kubernetes 1.24.0
SDKGracefulTermination feature has now graduated to beta. So by default, the sidecar container will not shutdown immeadiately on TERM signal, but instead wait for Shutdown state to occur.
A new PodHostname feature is now available, if you need to able to access a GameServer Pod within a cluster by a DNS name.
Agones release images have all been moved to Google Artifact Registry
Prior releases will still be accessible in their previous location
Updated dependencies for security fixes While we expect no issues, we also updated the gRPC libraries that Agones uses, so please make sure to test upgrades before deploying to production.

Check the README for details on features, installation and usage.

1.29.0 - Release Candidate

Wed, 11 Jan 2023 00:00:00 +0000

This is the 1.29.0-rc release of Agones.

We are bringing a huge release to start 2023!

Update Agones to support for Kubernetes 1.24.0
SDKGracefulTermination feature has now graduated to beta. So by default, the sidecar container will not shutdown immeadiately on TERM signal, but instead wait for Shutdown state to occur.
A new PodHostname feature is now available, if you need to able to access a GameServer Pod within a cluster by a DNS name.
Agones release images have all been moved to Google Artifact Registry
Updated dependencies for security fixes

While we expect no issues, we also updated the gRPC libraries that Agones uses, so please make sure to test upgrades before deploying to production.

1.28.0 - OpenShift Support, Player Tracking Metrics and GKE Terraform Improvements

Tue, 06 Dec 2022 00:00:00 +0000

This is the 1.28.0 release of Agones.

Highlights for this release include:

Support for OpenShift (where OwnerReferencesPermissionEnforcement is enabled)
Metrics for Player Tracking
GKE Terraform options for regional clusters and autoscaling

Check the README for details on features, installation and usage.

Implemented enhancements:

Add a FAQ entry describing when you would use Agones vs. StatefulSets #2770
Documentation: Kubernetes and Agones supported version matrix #2237
Immutable replicas field would allow PodDisruptionBudget on selected GameServer Pods #2806
Update example allocation yaml files to use selectors instead of required #2771
Only refresh certificates if the fsnotify event is relevant #1816
Terraform, GKE - add autoscaling Node Pools option #1467
Terraform, GKE - Option to create a Regional Cluster #1441
Adding AGONES_SDK_GRPC_HOST to NewSDK #1183
GameServer: Implement (immutable) scale subresource, add pdb #2807 (zmerlynn)
Sync Pod host ports back to GameServer in GCP #2782 (zmerlynn)
Players in-game metric for when PlayerTracking is enabled #2765 (estebangarcia)
Implemented PodDisruptionBudget on relevant deployments #2740 (valentintorikian)

See CHANGELOG for more details on changes.

1.28.0 - Release Candidate

Tue, 29 Nov 2022 00:00:00 +0000

This is the 1.28.0-rc release of Agones.

Highlights for this release include:

Support for OpenShift (where OwnerReferencesPermissionEnforcement is enabled)
Metrics for Player Tracking
GKE Terraform options for regional clusters and autoscaling

Check the README for details on features, installation and usage.

Implemented enhancements:

Immutable replicas field would allow PodDisruptionBudget on selected GameServer Pods #2806
Update example allocation yaml files to use selectors instead of required #2771
Only refresh certificates if the fsnotify event is relevant #1816
Terraform, GKE - add autoscaling Node Pools option #1467
Terraform, GKE - Option to create a Regional Cluster #1441
Adding AGONES_SDK_GRPC_HOST to NewSDK #1183
GameServer: Implement (immutable) scale subresource, add pdb #2807 (zmerlynn)
Sync Pod host ports back to GameServer in GCP #2782 (zmerlynn)
Players in-game metric for when PlayerTracking is enabled #2765 (estebangarcia)
Implemented PodDisruptionBudget on relevant deployments #2740 (valentintorikian)

Documentation: https://development.agones.dev/site/

1.27.0 - Go 1.19 and Cluster Autoscaler Improvements

Tue, 25 Oct 2022 00:00:00 +0000

This is the 1.27.0 release of Agones.

In this release Agones upgrades to Go 1.19 (from 1.17!), so we can take advantage of all the improvements therein.

This release has lots of important changes including:

Enable image streaming everywhere by default on GKE
Provide more flexibility on utilising the cluster autoscaler with graceful termination.
Reduced logging verbosity by wrapping an error into function.

Check the README for details on features, installation and usage.

1.27.0 - Release Candidate

Wed, 19 Oct 2022 00:00:00 +0000

This is the 1.27.0-rc release of Agones.

In this release Agones upgrades to Go 1.19 (from 1.17!), so we can take advantage of all the improvements therein.

This release has lots of important changes including:

Enable image streaming everywhere by default on GKE
Provide more flexibility on utilising the cluster autoscaler with graceful termination.
Reduced logging verbosity by wrapping an error into function.

Check the README for details on features, installation and usage.

1.26.0 - Kubernetes 1.23, Fleet and Metrics Optimisation and more!

Tue, 13 Sep 2022 00:00:00 +0000

This is the 1.26.0 release of Agones.

This release brings us support for Kubernetes 1.23, so if you are installing this release, remember to upgrade your clusters.

This release has lots of important bug fixes including:

Remove < Ready GameServers first when scaling down on the same node.
Fleet Autoscaler - Fleet name CRD Validation issue.
Fleet specific prometheus metrics to stop being exported when the fleet is deleted.
Fix for FleetAutoscaler keeps alive all TLS connections permanently causing memory leak on webhook server.
Fix for Default value on website for helm.installTests in helm chart setup.
Clear metric labels on Fleet/Autoscaler delete

Check the README for details on features, installation and usage.

1.26.0 - Release Candidate

Tue, 06 Sep 2022 00:00:00 +0000

This is the 1.26.0-rc release of Agones.

This release brings us support for Kubernetes 1.23, so if you are installing this release, remember to upgrade your clusters.

This release has lots of important bug fixes including:

Remove < Ready GameServers first when scaling down on the same node.
Fleet Autoscaler - Fleet name CRD Validation issue.
Fleet specific prometheus metrics to stop being exported when the fleet is deleted.
Fix for FleetAutoscaler keeps alive all TLS connections permanently causing memory leak on webhook server.
Fix for Default value on website for helm.installTests in helm chart setup.
Clear metric labels on Fleet/Autoscaler delete

Check the README for details on features, installation and usage.

1.25.0 - Unity SDK Alpha Support, Fleet Custom Sync Interval and more

Tue, 02 Aug 2022 00:00:00 +0000

This is the 1.25.0 release of Agones.

This release has lots of enhancements and bug fixes. This includes:

Move CustomFasSyncInterval to Beta.
Move NodeExternalDNS to stable.
Upgrade SuperTuxKart to 1.3.
Upgrade Xonotic to 0.8.5.
Add Alpha SDK support to the Unity SDK.

Check the README for details on features, installation and usage.

Implemented enhancements:

Upgrade Xonotic to 0.8.5 #2664
End to end tests for SDKGracefulTermination #2647
Move CustomFasSyncInterval to Beta #2646
Move NodeExternalDNS to stable #2643
Upgrade SuperTuxKart to 1.3 #2546
Docs: How to do local container with sdk #2677 (markmandel)
upgrade xonotic version #2669 (mridulji)
NodeExternalDNS/stable #2660 (SaitejaTamma)
Move CustomFasSyncInterval to Beta #2654 (govargo)
Support for Unity Alpha SDK #2600 (MaxHayman)

See CHANGELOG for more details on changes.

1.25.0 - Release Candidate

Tue, 26 Jul 2022 00:00:00 +0000

This is the 1.25.0-rc release of Agones.

This release has lots of enhancements and bug fixes. This includes:

Move CustomFasSyncInterval to Beta.
Move NodeExternalDNS to stable.
Upgrade SuperTuxKart to 1.3.
Upgrade Xonotic to 0.8.5.
Add Alpha SDK support to the Unity SDK.

Check the README for details on features, installation and usage.

Implemented enhancements:

Upgrade Xonotic to 0.8.5 #2664
End to end tests for SDKGracefulTermination #2647
Move CustomFasSyncInterval to Beta #2646
Move NodeExternalDNS to stable #2643
Upgrade SuperTuxKart to 1.3 #2546
Docs: How to do local container with sdk #2677 (markmandel)
upgrade xonotic version #2669 (mridulji)
NodeExternalDNS/stable #2660 (SaitejaTamma)
Move CustomFasSyncInterval to Beta #2654 (govargo)
Support for Unity Alpha SDK #2600 (MaxHayman) Documentation: https://development.agones.dev/site/ { end }

See CHANGELOG for more details on changes.

1.24.0 - Arm64, Fleet and SDK Bug Fixes

Tue, 21 Jun 2022 00:00:00 +0000

This is the 1.24.0 Release of Agones.

This release has lots of important bug fixes and documentation. This includes:

ARM64 image for the simple-game-server example.
Fix for scaling a fleet when a game server is allocated from an older version.
Fix for sdkServer.logLevel nil in Gameserver in local-mode.
sdkServer.logLevel in Gameserver config can now be used in local mode.

We also believe we’ve fixed all the issues with running on ARM64 clusters with this release, so please give a try.

1.24.0 - Release Candidate

Wed, 15 Jun 2022 00:00:00 +0000

This is the 1.24.0-rc Release of Agones.

This release has lots of important bug fixes and documentation. This includes:

ARM64 image for the simple-game-server example.
Fix for scaling a fleet when a game server is allocated from an older version.
Fix for sdkServer.logLevel nil in Gameserver in local-mode.
sdkServer.logLevel in Gameserver config can now be used in local mode.

We also believe we’ve fixed all the issues with running on ARM64 clusters with this release, so please give a try (especially while we are in RC and can potentially fix things before stable next week).

1.23.0 - Kubernetes 1.22 and initial arm support

Tue, 10 May 2022 00:00:00 +0000

This is the 1.23.0 release of Agones.

This release introduces initial support for running game servers on linux machines using the ARM architecture! If this is of interest to you, please test it out and give us feedback so that we can ensure that it works reliably before promoting the support to stable.

This release brings us support for Kubernetes 1.22, so if you are installing this release, please remember to upgrade your clusters.

1.23.0 - Release Candidate

Tue, 03 May 2022 00:00:00 +0000

This is the 1.23.0-rc release of Agones.

This release brings us support for Kubernetes 1.22, so if you are installing this release, please remember to upgrade your clusters.

1.22.0 - More Bug Fixes, Examples and Load Testing Tools

Mon, 04 Apr 2022 00:00:00 +0000

This is the 1.22.0 release of Agones.

This release has lots of important bug fixes, examples and tools. This includes:

Fix for Fleet rolling updates getting stuck when under high load.
Several SDK fixes, for both Go and C++.
Load testing framework for better load scenario testing.
A GCP specific multi-cluster allocation example,
Ability to integrate Agones internal certificates with cert-manager.

Check the README for details on features, installation and usage.

1.22.0 - Release Candidate

Tue, 22 Mar 2022 00:00:00 +0000

This is the 1.22.0-rc Release of Agones.

This release has lots of important bug fixes, examples and tools. This includes:

Fix for Fleet rolling updates getting stuck when under high load.
Several SDK fixes, for both Go and C++.
Load testing framework for better load scenario testing.
A GCP specific multi-cluster allocation example,
Ability to integrate Agones internal certificates with cert-manager.

Check the README for details on features, installation and usage.

1.21.0 - Lots of Bug Fixes!

Tue, 15 Feb 2022 00:00:00 +0000

This is a big bug fix release!

Not only did we fix a ton of flaky tests (which will make contributing easier), but also solved lots of tricky bugs in the process. This includes fixes to the alpha Fleet Autoscaling custom syncing, as well as quality of life improvements where we now validate metadata patches on GameServerAllocation.

If you are using Agones’ metrics, note that there is breaking change, in that the node_name label has been removed from allocation metrics to remove a potential cardinality bomb.

1.21.0 - Release Candidate

Tue, 08 Feb 2022 00:00:00 +0000

This is the 1.21.0-rc release of Agones.

This is a big bug fix release!

If you are using Agones’ metrics, note that there is breaking change, in that the node_name label has been removed from allocation metrics to remove a potential cardinality bomb.

1.20.0 - Updates to gRPC and Simple Game Server Example

Fri, 14 Jan 2022 00:00:00 +0000

This is the 1.20.0 release of Agones.

This release brings us the simple game server version 0.6 and grpc client and server on same version

Check the README for details on features, installation and usage.

Security fixes:

Upgrade terraform test dependencies. #2425 (markmandel)

Implemented enhancements:

Update the simple game server to move itself back to the Ready state after allocation #2409 (roberthbailey)
Add a flag to simple-game-server to shutdown after a specified number of seconds #2407 (roberthbailey)

See CHANGELOG for more details on changes.

1.20.0 - Release Candidate

Tue, 04 Jan 2022 00:00:00 +0000

This is the 1.20.0-rc release of Agones.

This release provides new functionality to the simple game server (now version 0.6), as well as bringing the grpc client and server to be the same version across the project.

Check the README for details on features, installation and usage.

Implemented enhancements:

Update the simple game server to move itself back to the Ready state after allocation #2409 (roberthbailey)
Add a flag to simple-game-server to shutdown after a specified number of seconds #2407 (roberthbailey)

Documentation: https://development.agones.dev/site/

1.19.0 - Kubernetes 1.21, SDKWatchSendOnExecute to stable, NodeExternalDNS to beta, Terraform 1.0

Tue, 23 Nov 2021 00:00:00 +0000

This is the 1.19.0 release of Agones.

This release brings us support for Kubernetes 1.21, so if you are installing this release, remember to upgrade your clusters.

The SDKWatchSendOnExecute feature has graduated to stable! And the feature NodeExternalDNS moved from alpha to beta and is enabled by default.

Terraform is upgraded to 1.0.

Check the README for details on features, installation and usage.

Breaking changes:

Upgrade to Kubernetes 1.21 #2311
Move NodeExternalDNS to Beta #2240
Upgrade client-go to v0.21.5. #2333 (roberthbailey)
Upgrade terraform to Kubernetes 1.21. #2326 (roberthbailey)

Implemented enhancements:

1.19.0 - Release Candidate

Tue, 16 Nov 2021 00:00:00 +0000

This is the 1.19.0-rc release of Agones.

This release brings us support for Kubernetes 1.21, so if you are testing this release candidate, remember to upgrade your clusters.

The SDKWatchSendOnExecute feature has graduated to stable! And the feature NodeExternalDNS moved from alpha to beta and is enabled by default.

Terraform is upgraded to 1.0

Check the README for details on features, installation and usage.

Breaking changes:

Upgrade to Kubernetes 1.21 #2311
Move NodeExternalDNS to Beta #2240

Implemented enhancements:

1.18.0 - gRPC compatibility fix, RollingUpdateOnReady to stable, SDKGracefulTermination in alpha

Tue, 12 Oct 2021 00:00:00 +0000

This is the v1.18.0 release of Agones.

This release fixes a gRPC compatibility issue in the allocator service introduced in Agones 1.11.0. If you have a gRPC client that does not work with the allocator server, you can now disable the REST server or set it to a different port for better client compatibility.

The RollingUpdateOnReady feature has graduated to stable! And the new alpha feature SDKGracefulTermination makes Agones work better with preemptible VMs.

1.18.0 - Release Candidate

Tue, 05 Oct 2021 00:00:00 +0000

This is the 1.18.0-rc release of Agones.

The RollingUpdateOnReady feature has graduated to stable! And the new alpha feature SDKGracefulTermination makes Agones work better with preemptible VMs.

1.17.0 - Kubernetes 1.20, deprecated required/preferred, add sync property to FleetAutoScaler

Tue, 31 Aug 2021 00:00:00 +0000

This is the 1.17.0 release of Agones.

This release brings us support for Kubernetes 1.20, so if you are installing this release, remember to upgrade your clusters.

Starting from this release, required and preferred are deprecated in GameServerAllocation Specification, please use selectors for future allocation match labels.

New functionality highlights in this release include:

Added a new property to Fleet Autoscaler for supporting custom sync interval (alpha).
Advanced allocation filters, including player capacity and game server state (alpha).

Check the README for details on features, installation and usage.

1.17.0 - Release Candidate

Thu, 26 Aug 2021 00:00:00 +0000

This is the 1.17.0-rc release of Agones.

This release brings us support for Kubernetes 1.20, so if you are testing this release candidate, remember to upgrade your clusters.

Check the README for details on features, installation and usage.

Breaking changes:

Upgrade to Kubernetes 1.20 #2186
Upgrade client-go to v0.20.9. #2194 (roberthbailey)

Implemented enhancements:

Pass game port to container as env variable #2201
Configurable custom resync period for FleetAutoscaler #1955
Docs: Player Capacity Integration Pattern #2229 (markmandel)
Docs: Canary Testing Integration Pattern #2227 (markmandel)
Create “Integration Patterns” section in docs #2215 (markmandel)
Update the GameServerAllocation Specification to remove required/pref… #2206 (cindy52)
Update proto and allocator for advanced allocation #2199 (markmandel)
GSA: Advanced Filtering via resource API #2188 (markmandel)
Upgrade terraform to Kubernetes 1.20. #2187 (roberthbailey)
Allow disabling of all allocator secrets in helm chart #2177 (sudermanjr)
Custom fleet autoscaler resync interval #2171 (jie-bao)
GSA: Switch LabelSelector to GameServerSelector #2166 (markmandel)

Security fixes:

1.16.0 - Kubernetes 1.19, golang 1.15

Tue, 20 Jul 2021 00:00:00 +0000

This is the 1.16.0 release of Agones.

This release brings us support for Kubernetes 1.19, so if you are testing this release candidate, remember to upgrade your clusters.

If you are using Fleet autoscalers with a webhook that is also configured with an SSL certificate, you will now be required to include a SAN in your certificate as Agones is now using Go 1.15. This migration was previously announced in the v1.11.0 release notes in December of last year.

1.16.0 - Release Candidate

Tue, 13 Jul 2021 00:00:00 +0000

This is the 1.16.0-rc release of Agones.

This release brings us support for Kubernetes 1.19, so if you are testing this release candidate, remember to upgrade your clusters.

1.15.0 - Azure AKS public IP per node/vm support

Tue, 08 Jun 2021 00:00:00 +0000

This is the 1.15.0 release of Agones.

This release brings Azure AKS support for public IP per node/vm.

Check the README for details on features, installation and usage.

Implemented enhancements:

Azure AKS support for public IP per Node/VM #2083
Unreal plugin WatchGameServer implementation #2064 (highlyunavailable)

See CHANGELOG for more details on changes.

Images available with this release:

Helm chart available with this release:

1.15.0 - Release Candidate

Tue, 01 Jun 2021 00:00:00 +0000

This is the 1.15.0-rc release of Agones.

This release brings Azure AKS support for public IP per node/vm.

Check the README for details on features, installation and usage.

Implemented enhancements:

Azure AKS support for public IP per Node/VM #2083
Unreal plugin WatchGameServer implementation #2064 (highlyunavailable)

Documentation: https://development.agones.dev/site/

See CHANGELOG for more details on changes.

Images available with this release:

Helm chart available with this release:

1.14.0 - Initial Windows Support, RollingUpdateOnReady to beta

Tue, 27 Apr 2021 00:00:00 +0000

This is the 1.14.0 release of Agones.

This release introduces initial support for running windows game servers! If this is of interest to you, please test it out and give us feedback so that we can ensure that it works reliably before promoting the support to stable.

It also moves the RollingUpdateOnReady feature to beta and makes it enabled by default.

Check the README for details on features, installation and usage.

1.14.0 - Release Candidate

Tue, 20 Apr 2021 00:00:00 +0000

This is the 1.14.0-rc release of Agones.

It also moves the RollingUpdateOnReady feature to beta and makes it enabled by default.

Check the README for details on features, installation and usage.

1.13.0 - Kubernetes 1.18, Websocket Watch SDK, Empty Ports

Tue, 16 Mar 2021 00:00:00 +0000

This is the 1.13.0 release of Agones.

This release brings us support for Kubernetes 1.18, so please remember to upgrade your clusters with this version.

Worth noting - if you rely on Agones generated client libraries, between Kubernetes 1.17 and 1.18 the API surface of client-go was changed to include a context.Context and Option struct, so you may need to change your code to accommodate that. This tool may be useful for a quick fix.

1.13.0 - Release Candidate

Tue, 09 Mar 2021 00:00:00 +0000

This is the 1.13.0-rc release of Agones.

This release brings us support for Kubernetes 1.18, so if you are testing this release candidate, remember to upgrade your clusters.

1.12.0 - Improved GameServer Validation

Tue, 02 Feb 2021 00:00:00 +0000

This is the 1.12.0 release of Agones.

A few things to note in this release:

The GameServer CRD now includes the full PodTemplateSpec json schema, to provide better up-front validation. This should be entirely backward compatible, but in case you run into issues, the helm configuration option gameservers.podPreserveUnknownFields is available to disable validation and field pruning.
- If you are using Helm, you might need to update your Helm version and/or do a clean install to apply this update to your cluster if you already have a version of Agones installed, due to the size of the CRD update.
SDKWatchSendOnExecute has been moved to Beta, so by default you will get a copy of the most recent GameServer information with your initial SDK.WatchGameServer(...) request.
The ability to apply port allocation to multiple containers has moved from Beta to Stable!

Check the README for details on features, installation and usage.

1.12.0 - Release Candidate

Tue, 26 Jan 2021 00:00:00 +0000

This is the 1.12.0-rc release of Agones.

A few things to note in this release:

The GameServer CRD now includes the full PodTemplateSpec json schema, to provide better up-front validation. This should be entirely backward compatible, but in case you run into issues, the helm configuration option gameservers.podPreserveUnknownFields is available to disable validation and field pruning.
- If you are using Helm, you might need to update your Helm version and/or do a clean install to apply this update to your cluster if you already have a version of Agones installed, due to the size of the CRD update.
SDKWatchSendOnExecute has been moved to Beta, so by default you will get a copy of the most recent GameServer information with your initial SDK.WatchGameServer(...) request.
The ability to apply port allocation to multiple containers has moved from Beta to Stable!

Check the README for details on features, installation and usage.

1.11.0 - Kubernetes 1.17 and REST API for Allocation

Tue, 22 Dec 2020 00:00:00 +0000

This is the 1.11.0 release of Agones.

This release includes several breaking changes, that include:

Upgrade supported Kubernetes version to 1.17
Upgrade CRDs to v1 from v1beta1, including adding structured schemas

For this reason, we request that users test this Release Candidate against their current installs to ensure there are no issues before it is moved to stable.

Also, of note: If you are using Fleet autoscalers with a webhook that is also configured with an SSL certificate, and are not using a SAN in your certificate, please update them with this release in preparation for a migration of the project to Go 1.15.

1.11.0 - Release Candidate

Tue, 15 Dec 2020 00:00:00 +0000

This is the 1.11.0-rc release of Agones.

This release includes several breaking changes, that include:

Upgrade supported Kubernetes version to 1.17
Upgrade CRDs to v1 from v1beta1, including adding structured schemas

For this reason, we request that users test this Release Candidate against their current installs to ensure there are no issues before it is moved to stable.

1.10.0 - Allocations go faster!

Tue, 10 Nov 2020 00:00:00 +0000

This is the 1.10.0 release of Agones.

This release fixes critical performance bugs in the gRPC Allocation endpoint, as well as fixing a memory leak inherited from client-go. Therefore, we recommend upgrading your install of Agones as soon as possible.

Check the README for details on features, installation and usage.

Breaking changes:

Remove the documentation for helm v2 #1859 (roberthbailey)

Security fixes:

update node.js dependencies #1868 (steven-supersolid)

Implemented enhancements:

Adding allocator log level #1879
Adding allocator resources #1873
Add troubleshooting section to allocator and multicluster allocation #1866
Helm setting the annotation of controller and allocator #1848
Change the multi-cluster allocation feature to stable version #1780
Updated C# documentation to use NuGet package #1769
Documented assumed prerequisite knowledge for the project #1759
Multicluster: Add gRPC dial timeout #1700
Add new projects to Third Party section of the site #1882 (danieloliveira079)
Add log level setting in allocator #1880 (8398a7)
Add troubleshooting for allocation gRPC request #1878 (pooneh-m)
Add allocator resources #1874 (8398a7)
[Unreal SDK] Added a response code check to some functions #1870 (dotcom)
Built tools: Update install with Allocation certs #1869 (markmandel)
Add gRPC load test for allocation service #1867 (ilkercelikyilmaz)
Add pod annotations #1849 (8398a7)
Useful Unreal links #1846 (domgreen)
Make the force_update option configurable in Helm/Terraform #1844 (comerford)
[Doc] Mark multicluster allocation feature as stable #1843 (pooneh-m)
Docs: Prerequisite Knowledge section #1821 (markmandel)
adding timeout to remote cluster allocate call and adding total timeout to allocate #1815 (kdima)
Docs: Update C# SDK docs page #1796 (Reousa)

See CHANGELOG for more details on changes.

1.10.0 - Release Candidate

Tue, 03 Nov 2020 00:00:00 +0000

This is the 1.10.0-rc release of Agones.

Check the README for details on features, installation and usage.

Breaking changes:

Remove the documentation for helm v2 #1859 (roberthbailey)

Security fixes:

update node.js dependencies #1868 (steven-supersolid)

Implemented enhancements:

Adding allocator log level #1879
Adding allocator resources #1873
Add troubleshooting section to allocator and multicluster allocation #1866
Helm setting the annotation of controller and allocator #1848
Change the multi-cluster allocation feature to stable version #1780
Updated C# documentation to use NuGet package #1769
Documented assumed prerequisite knowledge for the project #1759
Multicluster: Add gRPC dial timeout #1700
Add new projects to Third Party section of the site #1882 (danieloliveira079)
Add log level setting in allocator #1880 (8398a7)
Add troubleshooting for allocation gRPC request #1878 (pooneh-m)
Add allocator resources #1874 (8398a7)
[Unreal SDK] Added a response code check to some functions #1870 (dotcom)
Built tools: Update install with Allocation certs #1869 (markmandel)
Add gRPC load test for allocation service #1867 (ilkercelikyilmaz)
Add pod annotations #1849 (8398a7)
Useful Unreal links #1846 (domgreen)
Make the force_update option configurable in Helm/Terraform #1844 (comerford)
[Doc] Mark multicluster allocation feature as stable #1843 (pooneh-m)
Docs: Prerequisite Knowledge section #1821 (markmandel)
Docs: Update C# SDK docs page #1796 (Reousa)

Documentation: https://development.agones.dev/site/

1.9.0 - Kubernetes 1.16, NuGet and TCP+UDP

Tue, 29 Sep 2020 00:00:00 +0000

This is the 1.9.0 release of Agones.

Note: In this release we are upgrading the supported Kubernetes version to 1.16, so please make sure to upgrade your clusters.

Check the README for details on features, installation and usage.

Breaking changes:

Upgrade Kubectl to 1.16.15 #1806 (markmandel)
Upgrade client-go and apimachinery to 0.16.15 #1794 (markmandel)
Update GKE Terraform clusters to 1.16 #1772 (markmandel)
Upgrade to Kubernetes 1.16 #1649

Implemented enhancements:

[Doc] add a caveat on setting expiration for cert-manager certificate resources #1781
Helm chart: allow to specify loadBalancerIP #1709
Terraform, Helm module install: Allow gameserver namespaces and port ranges to be specified in terraform #1692
Support using the same port for both TCP/UDP forwarding #1523
Write Tests for Terraform configs #1227
Add player tracking and shutdown to the supertuxkart example server #1825 (sudermanjr)
Add logging for the client certificate verification #1812 (pooneh-m)
Troubleshooting - namespace stuck terminating #1795 (domgreen)
Add load balancer configuration for Helm options #1793 (yoshd)
Added option to hardcode load balancer IP for allocator. #1766 (devloop0)
Add TCPUDP protocol #1764 (Bmandk)
Publish to NuGet for Csharp SDK #1753 (markmandel)
Add Terraform example for GKE custom VPC deployment #1697 (moesy)
Fix Fleets RollingUpdate #1626 (aLekSer)

See CHANGELOG for more details on changes.

1.9.0 - Release Candidate

Tue, 22 Sep 2020 00:00:00 +0000

This is the 1.9.0-rc release of Agones.

Note: In this release we are upgrading the supported Kubernetes version to 1.16, so please make sure to upgrade your clusters.

Check the README for details on features, installation and usage.

Breaking changes:

Upgrade Kubectl to 1.16.15 #1806 (markmandel)
Upgrade client-go and apimachinery to 0.16.15 #1794 (markmandel)
Update GKE Terraform clusters to 1.16 #1772 (markmandel)
Upgrade to Kubernetes 1.16 #1649

Implemented enhancements:

[Doc] add a caveat on setting expiration for cert-manager certificate resources #1781
Helm chart: allow to specify loadBalancerIP #1709
Terraform, Helm module install: Allow gameserver namespaces and port ranges to be specified in terraform #1692
Support using the same port for both TCP/UDP forwarding #1523
Write Tests for Terraform configs #1227
Add player tracking and shutdown to the supertuxkart example server #1825 (sudermanjr)
Add logging for the client certificate verification #1812 (pooneh-m)
Troubleshooting - namespace stuck terminating #1795 (domgreen)
Add load balancer configuration for Helm options #1793 (yoshd)
Added option to hardcode load balancer IP for allocator. #1766 (devloop0)
Add TCPUDP protocol #1764 (Bmandk)
Publish to NuGet for Csharp SDK #1753 (markmandel)
Add Terraform example for GKE custom VPC deployment #1697 (moesy)
Fix Fleets RollingUpdate #1626 (aLekSer)

Documentation: https://development.agones.dev/site/

1.8.0 - SDK Improvements, Including a New Unreal SDK!

Tue, 18 Aug 2020 00:00:00 +0000

This is the 1.8.0 release of Agones.

Lots of changes to SDKs in this release, including a replacement Unreal SDK.

The previous Unreal SDK will continue to work, but we recommend users upgrade to this latest version, as it has far more functionality.

We also see more SDKs supporting the alpha Player Tracking functionality as well.

Check the README for details on features, installation and usage.

Breaking changes:

[Discussion] Assimilate netspeakgames/UnrealAgonesSDK #1683
move Netspeak Unreal SDK into Agones Unreal SDK #1739 (domgreen)

Security fixes:

1.8.0 - Release Candidate

Tue, 11 Aug 2020 00:00:00 +0000

This is the 1.8.0-rc release of Agones.

Check the README for details on features, installation and usage.

Lots of changes to SDKs in this release, including a replacement Unreal SDK.

The previous Unreal SDK will continue to work, but we recommend users upgrade to this latest version, as it has far more functionality.

We also see more SDKs supporting the alpha Player Tracking functionality as well.

Breaking changes:

[Discussion] Assimilate netspeakgames/UnrealAgonesSDK #1683
move Netspeak Unreal SDK into Agones Unreal SDK #1739 (domgreen)

Security fixes:

1.7.0 - Helm 3, Metrics, SDK and Allocation Improvements

Tue, 07 Jul 2020 00:00:00 +0000

This is the 1.7.0 release of Agones.

The ContainerPortAllocation feature has been moved to beta in this release, and the SDK.WatchGameServer() command has a new alpha feature to immediately return a result.

We also have new metric and dashboard features, upgraded all our documentation and testing to Helm 3, updated the C# SDK, improved the allocation endpoint system and more.

Check the README for details on features, installation and usage.

1.7.0 - Release Candidate

Tue, 30 Jun 2020 00:00:00 +0000

This is the 1.7.0-rc release of Agones.

The ContainerPortAllocation feature has been moved to beta in this release, and the SDK.WatchGameServer() command has a new alpha feature to immediately return a result.

We also have new metric and dashboard features, upgraded all our documentation and testing to Helm 3, updated the C# SDK, improved the allocation endpoint system and more.

Check the README for details on features, installation and usage.

1.6.0 - Player Tracking, Kubernetes 1.15, Node.js SDK Updates

Tue, 26 May 2020 00:00:00 +0000

This is the v1.6.0 release of Agones.

This release includes several breaking changes to be aware of:

Upgrade to required Kubernetes version to 1.15
The Alpha Multi Cluster Allocator API has been renamed, refactored slightly and moved to Stable. It is worth noting that Multi Cluster Allocation as a whole (installation, setup, etc) is still in beta, and may change in the future.
The node.js SDK has switched to grpc-js. It should be backward compatible, but please let us know if there are issues.

We are also excited to have a new major feature release of Player Tracking - keep track of which players are connected to you GameServers and what your GameServer capacities are!

Allocator Service

Fri, 25 Oct 2019 05:45:05 +0000

To allocate a game server, Agones provides a gRPC and REST service with mTLS authentication, called agones-allocator that can be used instead of GameServerAllocations .

Both gRPC and REST are accessible through a Kubernetes service that can be externalized using a load balancer. By default, gRPC and REST are served from the same port. However, either service can be disabled or the services can be served from separate ports using the helm configuration.

1.6.0 - Release Candidate

Tue, 19 May 2020 00:00:00 +0000

This is the v1.6.0-rc release of Agones.

This release includes several breaking changes to be aware of:

Upgrade to required Kubernetes version to 1.15
The Alpha Multi Cluster Allocator API has been renamed, refactored slightly and moved to Stable. It is worth noting that Multi Cluster Allocation as a whole (installation, setup, etc) is still in beta, and may change in the future.
The node.js SDK has switched to grpc-js. It should be backward compatible, but please let us know if there are issues.

We are also excited to have a new major feature release of Player Tracking - keep track of which players are connected to you GameServers and what your GameServer capacities are!

1.5.0 - C# SDK, Multiple Port Allocations, Agones FAQ

Mon, 13 Apr 2020 00:00:00 +0000

This is the 1.5.0 release of Agones.

This release sees the release of an official C# SDK, as well as our first Alpha feature, being able to allow port mapping to any container in the backing GameServer Pod.

Check the README for details on features, installation and usage.

Implemented enhancements:

FAQ for Agones #1460 (markmandel)
GameServer remains “STATE:Creating” if not create serviceaccount #1370
Site: Prioritise search results on agones.dev better #1327
Create and document rules of thumb for log levels in agones code #1223
Configurable Log Level for Agones controllers #1218
Refactor Docker files for gRPC between SDK and allocation #1115
C# SDK #884
Feature Gates: EnableAllFeatures #1448 (markmandel)
Local implementation of Set/GetPlayerCapacity #1444 (markmandel)
Alpha GameServer attributes added to SDK #1440 (markmandel)
Added version to stress tests files #1433 (akremsa)
Terraform: Add FeatureGates into helm release #1431 (aLekSer)
SuperTuxKart Game Server that allows AI connections #1424 (markmandel)
Fix wrong condition check for Memory limit #1418 (aLekSer)
Applied allocation test #1417 (akremsa)
Add shutdown duration option to Node.js simple #1413 (steven-supersolid)
Add sidecar memory resources setting #1402 (suecideTech)
Add ErrorHandling for failed to create pods because of forbidden #1400 (suecideTech)
Alpha SDK.SetPlayerCapacity & GetPlayerCapacity #1399 (markmandel)
Add feature gate block to Make install #1397 (markmandel)
Allow ports to be added to any container in a GS pod #1396 (benclive)
Adding the C# gRPC SDK #1315 (Reousa)

See CHANGELOG for more details on changes.

1.5.0 - Release Candidate

Mon, 06 Apr 2020 00:00:00 +0000

This is the 1.5.0-rc release of Agones.

This release sees the release of an official C# SDK, as well as our first Alpha feature, being able to allow port mapping to any container in the backing GameServer Pod.

Check the README for details on features, installation and usage.

Implemented enhancements:

GameServer remains “STATE:Creating” if not create serviceaccount #1370
Site: Prioritise search results on agones.dev better #1327
Create and document rules of thumb for log levels in agones code #1223
Configurable Log Level for Agones controllers #1218
Refactor Docker files for gRPC between SDK and allocation #1115
C# SDK #884
Feature Gates: EnableAllFeatures #1448 (markmandel)
Local implementation of Set/GetPlayerCapacity #1444 (markmandel)
Alpha GameServer attributes added to SDK #1440 (markmandel)
Added version to stress tests files #1433 (akremsa)
Terraform: Add FeatureGates into helm release #1431 (aLekSer)
SuperTuxKart Game Server that allows AI connections #1424 (markmandel)
Fix wrong condition check for Memory limit #1418 (aLekSer)
Applied allocation test #1417 (akremsa)
Add shutdown duration option to Node.js simple #1413 (steven-supersolid)
Add sidecar memory resources setting #1402 (suecideTech)
Add ErrorHandling for failed to create pods because of forbidden #1400 (suecideTech)
Alpha SDK.SetPlayerCapacity & GetPlayerCapacity #1399 (markmandel)
Add feature gate block to Make install #1397 (markmandel)
Allow ports to be added to any container in a GS pod #1396 (benclive)
Adding the C# gRPC SDK #1315 (Reousa)

Documentation: https://development.agones.dev/site/

1.4.0 - Kubernetes 1.14, Unreal SDK improvements, Reliability Improvements

Tue, 03 Mar 2020 00:00:00 +0000

This is the 1.4.0 release of Agones.

This release includes the upgrade to Kubernetes 1.14, so please be sure to upgrade your clusters.

The Node package has now been officially moved to NPM, away from Github packages as well. This includes the previous 1.3.0 release.

Between RC and Stable, critical issues with the Terraform scripts for GKE were discovered. In the process some duplicate example scripts for GKE were removed, and others were adjusted. So please review your GKE based Terraform Agones scripts still work, and adjust accordingly.

1.4.0 - Release Candidate

Tue, 25 Feb 2020 00:00:00 +0000

This is the 1.4.0-rc release of Agones.

This release includes the upgrade to Kubernetes 1.14, so please be sure to upgrade your clusters.

The Node package has now been officially moved to NPM, away from Github packages as well. This includes the previous 1.3.0 release.

Check the README for details on features, installation and usage.

Breaking changes:

Update documentation (examples and website) to use Kubernetes 1.14 #1364 (roberthbailey)
Update terraform configs to use Kubernetes 1.14 #1342 (roberthbailey)
Update developer tooling to Kubernetes 1.14 #1341 (roberthbailey)
Change the GameServerAllocationPolicy version to stable. #1332 (pooneh-m)
Changing the allocator API to gRPC #1314 (pooneh-m)

Implemented enhancements:

1.3.0 - More Terraform, Node packages and Unity SDK enhancements

Mon, 20 Jan 2020 00:00:00 +0000

This is the 1.3.0 release of Agones.

This release includes the Node SDK packaged as a NPM module and hosted on github. That being said, the functionality of the Node SDK has not changed, and previous versions will continue to work as normal.

The upgraded gRPC across Agones and SDKs is marked as a breaking change as a precaution, as we expect previous versions of the SDK to continue to work as per normal.

1.3.0 - Release Candidate

Mon, 13 Jan 2020 00:00:00 +0000

This is the 1.3.0-rc release of Agones.

The upgraded gRPC across Agones and SDKs is marked as a breaking change as a precaution, as we expect previous versions of the SDK to continue to work as per normal.

1.2.0 - Kubernetes 1.13, Local Dev, and Unity SDK

Tue, 10 Dec 2019 00:00:00 +0000

This is the 1.2.0 release of Agones.

This release includes an upgrade of the supported Kubernetes version from 1.12 to 1.13.

Make sure to check the Upgrading Guide for details on how to perform this upgrade safely.

Check the README for details on features, installation and usage.

Breaking changes:

Update client-go to kubernetes-1.13.12 #1189 (heartrobotninja)
Update the default gRPC and HTTP ports for the sdkserver for the 1.2.0 release #1180 (roberthbailey)
Update terraform configs to use Kubernetes 1.13 #1179 (roberthbailey)
Update documentation for the 1.2 release to use Kubernetes 1.13. #1178 (roberthbailey)
Update minikube and KIND developer tooling to Kubernetes 1.13 #1177 (roberthbailey)
Update the prow cluster to use Kubernetes 1.13 #1176 (roberthbailey)
Update GKE development tooling to Kubernetes 1.13 #1175 (roberthbailey)

Implemented enhancements:

1.2.0 - Release Candidate

Tue, 03 Dec 2019 00:00:00 +0000

This is the 1.2.0-rc release of Agones.

This release includes an upgrade of the supported Kubernetes version from 1.12 to 1.13.

Make sure to check the Upgrading Guide for details on how to perform this upgrade safely.

Check the README for details on features, installation and usage.

Breaking changes:

Update client-go to kubernetes-1.13.12 #1189 (heartrobotninja)
Update the default gRPC and HTTP ports for the sdkserver for the 1.2.0 release #1180 (roberthbailey)
Update terraform configs to use Kubernetes 1.13 #1179 (roberthbailey)
Update documentation for the 1.2 release to use Kubernetes 1.13. #1178 (roberthbailey)
Update minikube and KIND developer tooling to Kubernetes 1.13 #1177 (roberthbailey)
Update the prow cluster to use Kubernetes 1.13 #1176 (roberthbailey)
Update GKE development tooling to Kubernetes 1.13 #1175 (roberthbailey)

Implemented enhancements:

1.1.0 - Bug Fixes, Documentation and more

Mon, 28 Oct 2019 00:00:00 +0000

This is the 1.1.0 release of Agones.

Starting with the 1.1.0 release of Agones, the ports to which the sdkserver sidecar binds are now configurable. To take advantage of this feature, your game will need to use an updated SDK from the 1.1.0 release.

The default ports that the sdkserver binds to are ephemeral and can cause the sidecar to intermittently fail to start. For backwards compatibility with game servers compiled against the 1.0.0 SDKs, the default ports remain unchanged in this release but they will be changed in the next release of Agones to fix this bug. We strongly recommend that as part of upgrading to the 1.1.0 release of Agones you also update your game server containers to include the 1.1.0 SDK along with your game.

Multi-cluster Allocation

Fri, 25 Oct 2019 05:45:05 +0000

This implementation of multi-cluster allocation was written before managed and open source multi-cluster Service Meshes such as Istio and Linkerd, were available and so widely utilised.

We now recommend implementing a Service Mesh in each of your Agones clusters and backend services cluster to provide a multi-cluster allocation endpoint that points to each Agones cluster’s Allocation Service.

Service Mesh specific projects provide far more powerful features, easier configuration and maintenance, and we expect that they will be something that you will likely be installing in your multi-cluster architecture anyway.

1.1.0 - Release Candidate

Mon, 21 Oct 2019 00:00:00 +0000

This is the 1.1.0-rc release of Agones.

Check the README for details on features, installation and usage.

Breaking changes:

Change the API for allocator to allocation.proto #1123 (pooneh-m)

Implemented enhancements:

Allocator service should log the Agones version #1042
Allocation policy needs to expose namespace of the targeted cluster #980
Configurable log level for agones sidecar #971
Add dynamic configuration of the sidecar http port to the unreal sdk. #1131 (roberthbailey)
Retry on failures for multi-cluster allocation #1130 (pooneh-m)
Simplify the selection of the dynamic port in the nodejs sdk. #1128 (roberthbailey)
Simplify the selection of the dynamic port in the Go sdk. #1127 (roberthbailey)
Added dynamic configuration of http port in the rust sdk #1125 (roberthbailey)
Added dynamic configuration of http port in the unity sdk #1121 (roberthbailey)
Implement converters between the GameServerAllocation API and allocation.proto #1117 (pooneh-m)
Add AltaVR logo to companies using Agones #1103 (TimoSchmechel)
Use an environment variable to dynamically set the grpc port in the nodejs sdk #1093 (roberthbailey)
Set the port to connect to the sdkserver based on the AGONES_SDK_GRPC_PORT environment variable #1092 (roberthbailey)
Use environment variables to dynamically set the grpc port in the golang sdk. #1086 (roberthbailey)
Add mcmahan.games to the companies using agones list. #1085 (benmcmahan)
Add missing “/reserve” endpoint description #1083 (aLekSer)
Add SDK server HTTP API test #1079 (aLekSer)
Sdkserver port configuration #1078 (roberthbailey)
Fixes, more e2e tests and logging for multi-cluster allocation #1077 (pooneh-m)
Longer blog post for Agones 1.0.0 announcement #1076 (markmandel)
Add a delay flag to the sdkserver #1070 (roberthbailey)
Adding namespace for multi-cluster allocation policy #1052 (pooneh-m)
Logging Agones version and port on the startup. #1048 (pooneh-m)
Adding make file to generate allocation go from proto #1041 (pooneh-m)
Add Sidecar log level parameter to GS specification #1007 (aLekSer)

Security fixes:

Announcing Agones 1.0.0

Wed, 25 Sep 2019 22:52:15 +0000

History

In 2017, Agones started as a collaboration between Ubisoft and Google Cloud to develop a turn-key, open source, solution for running, scaling and orchestrating multiplayer dedicated game servers on top of Kubernetes. They shared an equal vision of expanding the impact of open source in game development, especially in the infrastructure and multiplayer space, and an equal understanding of the power and capabilities of Kubernetes and how it could be extended to work with dedicated, authoritative, simulation game servers.

1.0.0 - A Huge Milestone!

Mon, 16 Sep 2019 00:00:00 +0000

This is the 1.0.0 release of Agones 🎉

Agones is now ready for production workloads. Unless otherwise indicated (by an alpha version), this API surface is now stable, and all endeavours will be made to maintain its backward compatibility.

Congratulations to everyone involved for code, bug reports, feedback, usage and more.

Check the README for details on features, installation and usage.

Implemented enhancements:

JSON serialisation error reporting on Mutation/Validation webhooks #992
CRASH for simple-udp example #1032 (markmandel)
Rust SDK: Reserved #1030 (markmandel)
Define the proto definition for the allocator service #1025 (pooneh-m)
Documentation on Fleet Updates and Upgrades #1020 (markmandel)
Documentation on how to upgrade Agones and/or Kubernetes. #1008 (markmandel)
Output JSON unmarshal error as Admission response #1005 (aLekSer)
Add GameServer troubleshooting guide #1003 (markmandel)
Local SDK Server: Add proper GS state handling #979 (aLekSer)
Add allocations metrics #963 (cyriltovena)

See CHANGELOG for more details on changes.

1.0.0 - Release Candidate

Mon, 09 Sep 2019 00:00:00 +0000

This is the 1.0.0-rc release of Agones.

We continues with documentation updates, making some improvements to local development tools and improving error validation handling.

Next week will be the stable 1.0.0 release 🎉

We are now in feature freeze until Tuesday, 17th of September. This means only docs, bug fixes and tests PRs will be merged during this time.
(Other PRs will be labelled feature-freeze-do-not-merge and will be held until after that date)

0.12.0 - Preparation for 1.0

Mon, 05 Aug 2019 00:00:00 +0000

This is the 0.12.0 stable release of Agones.

This release includes all breaking changes that are required for the 1.0 release that is coming in the release in September - so please review the breaking changes below, and the link to the updated documentation below to see all the changes that have occurred in this release.

This includes moving all CRDs to v1, and upgrading to Kubernetes 1.12 as the supported platform.

Tutorial Build and Run a Simple Gameserver (Rust)

Thu, 01 Aug 2019 10:00:00 +0000

Objectives

Run a simple gameserver
Understand how the simple gameserver uses the Agones Rust SDK
Build a customized version of the simple gameserver
Run your customized simple gameserver

Prerequisites

Docker
Agones installed on GKE
kubectl properly configured
A local copy of the Agones repository
A repository for Docker images, such as Docker Hub or GC Container Registry

To install on GKE, follow the install instructions (if you haven’t already) at Setting up a Google Kubernetes Engine (GKE) cluster. Also complete the “Installing Agones” instructions on the same page.

0.12.0 - Release Candidate

Tue, 30 Jul 2019 00:00:00 +0000

This includes moving all CRDs to v1, and upgrading to Kubernetes 1.12 as the supported platform.

We’ve also worked to complete functionality across GameServer SDKs, but we still have some work left.

Tutorial Build and Run a Simple Gameserver (node.js)

Thu, 01 Aug 2019 10:00:00 +0000

Objectives

Run a simple gameserver
Understand how the simple gameserver uses the Agones node.js SDK
Build a customized version of the simple gameserver
Run your customized simple gameserver

Prerequisites

Docker
Agones installed on GKE
kubectl properly configured
A local copy of the Agones repository
A repository for Docker images, such as Docker Hub or GC Container Registry

Tutorial Build and Run a Simple Gameserver (C++)

Thu, 01 Aug 2019 10:00:00 +0000

Objectives

Run a simple gameserver
Understand how the simple gameserver uses the Agones C++ SDK
Build a customized version of the simple gameserver
Run your customized simple gameserver

Prerequisites

Docker
Agones installed on GKE
kubectl properly configured
A local copy of the Agones repository
A repository for Docker images, such as Docker Hub or GC Container Registry

0.11.0 - Unity SDK, Better Packing, and More

Mon, 24 Jun 2019 00:00:00 +0000

More awesome things in this release! Massive thanks to the community for working on Agones 👏

Unity SDK!
Better packing on GameServerAllocation without a drop in performance.
Being able to use the same container port as the externally exposed port
and much more!

Check the README for details on features, installation and usage.

Breaking changes:

Move FleetAutoscaling to autoscaling.agones.dev group #829 (markmandel)
Fixing SDK proto file according to style guide #776 (aLekSer)

Implemented enhancements:

0.11.0 - Release Candidate

Mon, 17 Jun 2019 00:00:00 +0000

This cycles release candidate! Test is out for the next week, and try out the new features:

Unity SDK!
Better packing on GameServerAllocation without a drop in performance.
Being able to use the same container port as the externally exposed port
and much more!

We are now in feature freeze until Tuesday, 25th of June. This means only docs, bug fixes and tests PRs will be merged during this time.
(Other PRs will be labelled feature-freeze-do-not-merge and will be held until after that date)

0.10.0 - Unreal, Self Allocation and Performance Improvements

Mon, 13 May 2019 00:00:00 +0000

Great stuff in this release!

Unreal Server SDK!
GameServers can self Allocate
Faster Allocations

As always, huge thanks to the team of people working on Agones!

Check the README for details on features, installation and usage.

Breaking changes:

Add status subresource for FleetAutoscaler #730 (aLekSer)
Implement GameServerAlocation as API Extension #682 (markmandel)

Implemented enhancements:

Implementing cross cluster allocation request #757 (pooneh-m)
Rename APIServerEndpoint to AllocationEndpoint for multi-cluster allocation #755 (pooneh-m)
Implement multicluster allocation for local cluster allocation. #753 (pooneh-m)
Implementing cluster selector from multi-cluster allocation policies. #733 (pooneh-m)
Added Supersolid logo to the homepage #727 (KamiShepard)
Implementation of SDK.Allocate() #721 (markmandel)
Add allocation policy CRD and schema definition. #698 (pooneh-m)
Helm support for Terraform #696 (aLekSer)
Implement lacking functions in Rust SDK #693 (thara)
Terraform support to generate test cluster #670 (aLekSer)
Lightweight library for implementing APIServer extensions #659 (markmandel)
Unreal Engine 4 Plugin #647 (YannickLange)

Documentation: https://development.agones.dev/site/

0.10.0 - Release Candidate

Mon, 06 May 2019 00:00:00 +0000

Great stuff in this release!

Unreal Server SDK!
GameServers can self Allocate
Faster Allocations

We are now in feature freeze until Tuesday, 14th of May. This means only docs, bug fixes and tests PRs will be merged during this time.
(Other PRs will be marked as “merge-after-release” and will be held until after that date)

Check the README for details on features, installation and usage.

Breaking changes:

Add status subresource for FleetAutoscaler #730 (aLekSer)
Implement GameServerAlocation as API Extension #682 (markmandel)

Implemented enhancements:

0.9.0 - The SDK Release!

Mon, 01 Apr 2019 00:00:00 +0000

There is a new Node SDK in this release, and CMake support for our C++ SDK as well!

As always, huge thanks to the team of people working on Agones!

This is the 0.9.0 release of Agones.

Check the README for details on features, installation and usage.

Breaking changes:

Consistency: Portpolicy static=>Static & dynamic=>Dynamic #617 (markmandel)

Implemented enhancements:

Adding a section in the documentation about deploying Agones using GCP Marketplace. #664 (bbf)
Add Agones Kubernetes API docs generator #645 (aLekSer)
Added support for persisting logs in ’emptyDir’ volume attached to agones controller. #620 (jkowalski)
Adding Locust tests - initial changes for #412 #611 (pm7h)
Emit stress test metrics in Fortio format. #586 (jkowalski)
Add Node.js SDK and example - closes #538 #581 (steven-supersolid)
Cpp sdk cmake #464 (dsazonoff)

Security fixes:

0.9.0 - Release Candidate

Mon, 25 Mar 2019 00:00:00 +0000

New Node SDK in this release, and CMake support for our C++ SDK as well! Check it out!

We are now in feature freeze until Tuesday, 2nd of April. This means only docs, bug fixes and tests PRs will be merged during this time.
(Other PRs will be marked as “merge-after-release” and will be held until after that date)

Details:

Check the README for details on features, installation and usage.

Breaking changes:

GameServer Pod Service Accounts

Mon, 01 Apr 2019 00:00:00 +0000

Default Settings

By default, Agones sets up service accounts and sets them appropriately for the Pods that are created for GameServers.

Since Agones provides GameServer Pods with a sidecar container that needs access to Agones Custom Resource Definitions, Pods are configured with a service account with extra RBAC permissions to ensure that it can read and modify the resources it needs.

Since service accounts apply to all containers in a Pod, Agones will automatically overwrite the mounted key for the service account in the container that is running the dedicated game server in the backing Pod. This is done since game server containers are exposed publicly, and generally don’t require the extra permissions to access aspects of the Kubernetes API.

0.8.1 - Helm Configuration Hotfix

Thu, 14 Mar 2019 00:00:00 +0000

Hotfixes to Helm configuration options, and bug fixes.

As always, huge thanks to the team of people working on Agones!

Details: Check the README for details on features, installation and usage.

This is the 0.8.1 release of Agones.

Check the README for details on features, installation and usage.

Merged pull requests:

Tarballing source into the images for dependencies that are required by their licenses. #634 (bbf)
2 Hotfixes: Allow Helm to reference image digests and inject licenses #631 (bbf)
[Hotfix] Prep work for hotfix 0.8.1 #628 (markmandel)

See CHANGELOG for more details on changes.

0.8.0 - GameServerAllocations, Performance Improvements, Monitoring Improvements and more!

Wed, 20 Feb 2019 00:00:00 +0000

So many amazing features in this release!

More sophisticated allocation with GameServerAllocation
More metrics and dashboards
Build in support for node selection on Agones deployments
Stackdriver support

And more (see below) – download it now, and take it for a spin!

As always, huge thanks to the team of people working on Agones!

Details: This is the 0.8.0 release of Agones.

Check the README for details on features, installation and usage.

0.8.0 - Release Candidate

Wed, 13 Feb 2019 00:00:00 +0000

Our biggest release ever! Lots of awesome new features, so please take them for a spin!

We are now in feature freeze until Tuesday, 19th of February. This means only docs, bug fixes and tests PRs will be merged during this time. (Other PRs will be marked as “merge-after-release” and will be held until after that date)

Details: https://github.com/agones-dev/agones/releases/tag/v0.8.0-rc

Check the README for details on features, installation and usage.

Documentation: https://development.agones.dev/site/

Security fixes:

Welcome to the new Agones Website!

Thu, 17 Jan 2019 00:00:00 +0000

Welcome to the new Agones website!

We’ve implemented a new website, to enable lots of new functionality that we’re hoping to take advantage of now and in the future:

Ability to support multiple languages
Able to write documentation for new features, but keep them hidden until they are released.
Search!
Pretty Pictures! 😊
Easy access to older versions of the documentation

Big thanks to Hugo for being the static site generator, and the docsy team for the core documentation theme 👍

0.7.0 - latency measuring, fleet autoscaling webhooks, and metrics!

Tue, 08 Jan 2019 00:00:00 +0000

Massive release with 0.7.0!

Lots of great new features, from latency measuring tools, fleet autoscaling webhooks and OpenCensus metrics! Take them a spin, and let us know how they go.

As always, thanks to everyone involved - several new faces in this release providing new features, and feedback - awesome to see the community grow! 👌🌱

Details: https://github.com/agones-dev/agones/releases/tag/v0.7.0

Check the README for details on features, installation and usage.

Breaking changes:

Update to Kubernetes 1.11 #447 (markmandel)
Remove crd-install hook, as it break CRD updates #441 (markmandel)

Implemented enhancements:

Quickstart: Edit a Game Server

Wed, 02 Jan 2019 06:42:56 +0000

This guide addresses Google Kubernetes Engine and Minikube. We would welcome a Pull Request to expand this to include other platforms as well.

Prerequisites

A Go environment
Docker
Agones installed on GKE or Minikube
kubectl properly configured

To install on GKE, follow the install instructions (if you haven’t already) at Setting up a Google Kubernetes Engine (GKE) cluster. Also complete the “Enabling creation of RBAC resources” and “Installing Agones” sets of instructions on the same page.

Agones Kubernetes API

Mon, 01 Jan 0001 00:00:00 +0000

Packages:

agones.dev/v1

Package v1 is the v1 version of the API.

Resource Types:

Fleet

Fleet is the data structure for a Fleet resource

Field Description

apiVersion
string agones.dev/v1

kind
string Fleet

metadata
Kubernetes meta/v1.ObjectMeta Refer to the Kubernetes API documentation for the fields of the metadata field.

spec
FleetSpec

replicas
int32

Replicas are the number of GameServers that should be in this set. Defaults to 0.

Custom Controller for Agones Game Servers

Mon, 01 Jan 0001 00:00:00 +0000

Prerequisite

To get started, ensure the following prerequisites are met:

You have a running Kubernetes cluster.
Agones is installed on your cluster. Refer Agones guide.
(Optional) Review Custom Controller code to see the details of this example.

Create a Custom Controller

Let’s create a custom controller on your cluster using the following command:

kubectl apply -f https://raw.githubusercontent.com/googleforgames/agones/main/examples/custom-controller/deployment.yaml

When you run this command, it quickly sets up your controller by doing four things:

Build and Run a Simple Game Server that Connects to an Inference Server

Mon, 01 Jan 0001 00:00:00 +0000

Setting up the GenAI Inference Server

You will need a separate GenAI inference server. This example uses the Google for Games GenAI as its inference server. This particular inference server has the request structure for the /chat endpoint:

type GenAIRequest struct {
	Context         string  `json:"context,omitempty"`
	Prompt          string  `json:"prompt"`
}

(Optional) Modify the GenAIRequest Structure

If you need a different request structure for your GenAI endpoint, you will need to clone or fork the Agones repository and modify the above GenAIRequest struct in main.go. Update REPOSITORY in the agones/examples/simple-genai-server/Makefile to your own container registry and run make build && make push from within the agones/examples/simple-genai-server path. Then modify the gameserver_*.yaml to pull the image from your container registry. If you are making a series of changes you may also want to add imagePullPolicy: Always to the container image in gameserver_*.yaml.

Search Results

Mon, 01 Jan 0001 00:00:00 +0000

Deploying and Running SuperTuxKart Server Using Agones

Mon, 01 Jan 0001 00:00:00 +0000

Prerequisite

To get started, ensure the following prerequisites are met:

You have a running Kubernetes cluster.
Agones is installed on your cluster. Refer to the Agones guide for the instructions.
The SuperTuxKart client downloaded for gameplay. Download it from SuperTuxKart
(Optional) Review SuperTuxKart code to see the details of this example.

Create a Fleet

Let’s create a Fleet using the following command:

kubectl apply -f https://raw.githubusercontent.com/googleforgames/agones/main/examples/supertuxkart/fleet.yaml

You should see a successful output similar to this :

Deploying and Running Xonotic Server Using Agones

Mon, 01 Jan 0001 00:00:00 +0000

Prerequisite

To get started, ensure the following prerequisites are met:

You have a running Kubernetes cluster.
Agones is installed on your cluster. Refer to the Agones guide for the instructions.
The Xonotic client downloaded for gameplay. Download it from Xonotic
(Optional) Review Xonotic code to see the details of this example.

Create a Fleet

Let’s create a Fleet using the following command:

kubectl apply -f https://raw.githubusercontent.com/googleforgames/agones/main/examples/xonotic/fleet.yaml

You should see a successful output similar to this :

Agones

System Diagram

Agones Control Plane

agones-allocator

agones-controller

Feature Stages

Supported Versions

Agones Features

Feature Gates

Matchmaker requests a GameServer from a Fleet

Sample GameServerAllocation

Next Steps:

Unreal Engine Game Server Client Plugin

SDK Functionality

Third Party Videos and Presentations

Case Studies

Engineering Without Limits: A Decade of Kubernetes Powering PlayStation’s Evolution (Kubecon NA, 2025)

No More Disruption: PlayStation Network’s Approaches To Avoid Outages on Kubernetes Platform (Kubecon Japan, 2025)

(Paywall) ‘Monster Hunter Wilds’ Network Architecture Supporting Over 1 Million Concurrent Users (Presented by AWS) (Devcom, 2025)

Scheduling and Autoscaling

Cluster Autoscaler

GameServer Specification

Quickstart: Create a Game Server

Prerequisites

Google Kubernetes Engine

Before you begin

Choosing a shell

Installing Agones on Google Kubernetes Engine using Terraform

Before you begin

Choosing a shell

Install Agones using YAML

Installing Agones

Unity Game Server Client SDK

SDK Functionality

Third Party Articles

Case Studies

2025

2023

Blogs

2026

2025

2024

2021

2019

2018

High Availability Agones

High Availability for Agones Controller

Controlling Disruption

Disruption in Kubernetes

Matchmaker requires game server process registration

Next Steps:

Windows Gameservers

Prerequisites

Installing Agones on AWS Elastic Kubernetes Service using Terraform

Installation

Creating Cluster

Third Party Podcasts

2024

2021

2020

2019

2018

Fleet Updates

Rolling Update Strategy

Fleet Specification

GameServer Health Checking

Disabling Health Checking

SDK API

C++ Game Server Client SDK

SDK Functionality

Installation

Download

Quickstart: Create a Game Server Fleet

Prerequisites

Amazon Elastic Kubernetes Service

Allowing UDP Traffic

Installing Agones on Azure Kubernetes Service using Terraform

Installation

Install Agones using Helm

Prerequisites

`agones-allocator`

`agones-controller`

Sample `GameServerAllocation`