gameserverallocation.yaml

---
# Copyright 2018 Google LLC All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

#
# Full example of a GameServerAllocation. This is used to allocate
# A GameServer out of a set of GameServers. This could be a Fleet,
# multiple Fleets, or a self managed group of GameServers.
#

#
# For a full reference and details: https://agones.dev/site/docs/reference/gameserverallocation/
#
apiVersion: allocation.agones.dev/v1
kind: GameServerAllocation
metadata:
  name: allocation-example
spec:
  # GameServer selector from which to choose GameServers from.
  # GameServers still have the hard requirement to be `Ready` to be allocated from.
  # However, we can also make available `matchExpressions` for even greater flexibility.
  # Below is an example of a GameServer allocated against a given fleet.
  # See: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/ for more details
  # The selectors is an ordered list of allocations set.
  # If the first selector is not matched, the selection attempts the second selector, and so on.
  # This is useful for things like smoke testing of new game servers.
  # This also supports `matchExpressions`
  selectors:
    - matchLabels:
        agones.dev/fleet: green-fleet
    - matchLabels:
        agones.dev/fleet: blue-fleet
    - matchLabels:
        game: my-game
      matchExpressions:
        - {key: tier, operator: In, values: [cache]}
      # Specifies which State is the filter to be used when attempting to retrieve a GameServer
      # via Allocation. Defaults to "Ready". The only other option is "Allocated", which can be used in conjunction with
      # label/annotation/player selectors to retrieve an already Allocated GameServer.
      gameServerState: Ready
      # [Stage:Beta]
      # [FeatureFlag:CountsAndLists]
      counters:  # selector for counter current values of a GameServer count
        rooms:
          minCount: 1  # minimum value. Defaults to 0.
          maxCount: 5  # maximum value. Defaults to max(int64)
          minAvailable: 1  # minimum available (current capacity - current count). Defaults to 0.
          maxAvailable: 10  # maximum available (current capacity - current count) Defaults to max(int64)
      lists:
        players:
          containsValue: "x6k8z"  # only match GameServers who has this value in the list. Defaults to "", which is all.
          minAvailable: 1  # minimum available (current capacity - current count). Defaults to 0.
          maxAvailable: 10  # maximum available (current capacity - current count) Defaults to 0, which translates to max(int64)
      #
      # [Stage:Alpha]
      # [FeatureFlag:PlayerAllocationFilter]
      # Provides a filter on minimum and maximum values for player capacity when retrieving a GameServer
      # through Allocation. Defaults to no limits.
      players:
        minAvailable: 0
        maxAvailable: 99
  # 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
  # Optional custom metadata that is added to the game server at allocation
  # You can use this to tell the server necessary session data
  metadata:
    labels:
      mode: deathmatch
    annotations:
      map: garden22
  # yamllint disable rule:comments-indentation rule:line-length
  # [Stage: Beta]
  # [FeatureFlag:CountsAndLists]
  # `Priorities` configuration alters the order in which `GameServers` are searched for matches to the configured `selectors`.
  #
  # Priority of sorting is in descending importance. I.e. The position 0 `priority` entry is checked first.
  #
  # For `Packed` strategy sorting, this priority list will be the tie-breaker within the least utilised infrastructure, to ensure optimal
  # infrastructure usage while also allowing some custom prioritisation of `GameServers`.
  #
  # For `Distributed` strategy sorting, the entire selection of `GameServers` will be sorted by this priority list to provide the
  # order that `GameServers` will be allocated by.
  # Optional.
  priorities:
    - type: Counter  # Whether a Counter or a List.
      key: rooms  # The name of the Counter or List.
      order: Ascending  # "Ascending" lists smaller available capacity first.
  # [Stage:Beta]
  # [FeatureFlag:CountsAndLists]
  # Counter actions to perform during allocation. Optional.
  counters:
    rooms:
      action: Increment  # Either "Increment" or "Decrement" the Counter’s Count.
      amount: 1  # Amount is the amount to increment or decrement the Count. Must be a positive integer.
      capacity: 5  # Amount to update the maximum capacity of the Counter to this number. Min 0, Max int64.
  # List actions to perform during allocation. Optional.
  lists:
    players:
      addValues:  # appends values to a List’s Values array. Any duplicate values will be ignored
        - x7un
        - 8inz
      capacity: 40  # Updates the maximum capacity of the Counter to this number. Min 0, Max 1000.
      deleteValues:  # removes values from a List's Valules array. Any nonexistant values are ignored.
        - alice
        - bob