Scheduling Strategies

const (
    // Packed scheduling strategy will prioritise allocating GameServers
    // on Nodes with the most Allocated, and then Ready GameServers
    // to bin pack as many Allocated GameServers on a single node.
    // This is most useful for dynamic Kubernetes clusters - such as on Cloud Providers.
    // In future versions, this will also impact Fleet scale down, and Pod Scheduling.
    Packed SchedulingStrategy = "Packed"

    // Distributed scheduling strategy will prioritise allocating GameServers
    // on Nodes with the least Allocated, and then Ready GameServers
    // to distribute Allocated GameServers across many nodes.
    // This is most useful for statically sized Kubernetes clusters - such as on physical hardware.
    // In future versions, this will also impact Fleet scale down, and Pod Scheduling.
    Distributed SchedulingStrategy = "Distributed"
)

switch gsa.Spec.Scheduling {
case apis.Packed:
    loop = func(list []*agonesv1.GameServer, f func(i int, gs *agonesv1.GameServer)) {
        for i, gs := range list {
            f(i, gs)
        }
    }

apiVersion: agones.dev/v1
kind: Fleet
metadata:
  name: cloud-fleet
spec:
  replicas: 100
  scheduling: Packed  # Default
  template:
    spec:
      ports:
      - name: default
        containerPort: 7654
        portPolicy: Dynamic
      template:
        spec:
          containers:
          - name: game-server
            image: my-game:latest

apiVersion: allocation.agones.dev/v1
kind: GameServerAllocation
metadata:
  name: packed-allocation
spec:
  scheduling: Packed
  selectors:
  - matchLabels:
      agones.dev/fleet: cloud-fleet

Before Allocation:
Node 1: [GS1] [GS2] [GS3] [ ]  # 3 allocated
Node 2: [GS4] [GS5] [ ] [ ]     # 2 allocated  
Node 3: [ ] [ ] [ ] [ ]         # 0 allocated

After Packed Allocation:
Node 1: [GS1] [GS2] [GS3] [NEW] # Fills Node 1 first
Node 2: [GS4] [GS5] [ ] [ ]     # Unchanged
Node 3: [ ] [ ] [ ] [ ]         # Unchanged

Benefit: Node 3 can be scaled down

case apis.Distributed:
    // randomised looping - make a list of indices, and then randomise them
    // as we don't want to change the order of the gameserver slice
    if !runtime.FeatureEnabled(runtime.FeatureCountsAndLists) || len(gsa.Spec.Priorities) == 0 {
        l := len(list)
        indices := make([]int, l)
        for i := 0; i < l; i++ {
            indices[i] = i
        }
        rand.Shuffle(l, func(i, j int) {
            indices[i], indices[j] = indices[j], indices[i]
        })

        loop = func(list []*agonesv1.GameServer, f func(i int, gs *agonesv1.GameServer)) {
            for _, i := range indices {
                f(i, list[i])
            }
        }
    }

apiVersion: agones.dev/v1
kind: Fleet
metadata:
  name: onprem-fleet
spec:
  replicas: 100
  scheduling: Distributed
  template:
    spec:
      ports:
      - name: default
        containerPort: 7654
        portPolicy: Dynamic
      template:
        spec:
          containers:
          - name: game-server
            image: my-game:latest

apiVersion: allocation.agones.dev/v1
kind: GameServerAllocation
metadata:
  name: distributed-allocation
spec:
  scheduling: Distributed
  selectors:
  - matchLabels:
      agones.dev/fleet: onprem-fleet

Before Allocation:
Node 1: [GS1] [GS2] [GS3] [ ]  # 3 allocated
Node 2: [GS4] [GS5] [ ] [ ]     # 2 allocated
Node 3: [ ] [ ] [ ] [ ]         # 0 allocated

After Distributed Allocation:
Node 1: [GS1] [GS2] [GS3] [ ]  # Unchanged
Node 2: [GS4] [GS5] [ ] [ ]     # Unchanged
Node 3: [NEW] [ ] [ ] [ ]       # Fills Node 3 (least utilized)

Benefit: Load is evenly distributed

apiVersion: agones.dev/v1
kind: Fleet
metadata:
  name: my-fleet
spec:
  replicas: 100
  scheduling: Packed  # or Distributed
  template:
    # GameServer template

apiVersion: allocation.agones.dev/v1
kind: GameServerAllocation
spec:
  # Override Fleet default
  scheduling: Distributed
  selectors:
  - matchLabels:
      agones.dev/fleet: my-fleet

apiVersion: allocation.agones.dev/v1
kind: GameServerAllocation
spec:
  scheduling: Distributed
  selectors:
  - matchLabels:
      agones.dev/fleet: my-fleet
  # Custom priorities for fine-grained control
  priorities:
  - type: Counter
    key: rooms
    order: Ascending  # Prefer servers with fewer rooms
  - type: List
    key: players
    order: Descending  # Then prefer servers with more players

// For FeatureCountsAndLists we do not do randomized looping -- instead choose the game
// server based on the list of Priorities. (The order in which the game servers were sorted
// in ListSortedGameServersPriorities.)
loop = func(list []*agonesv1.GameServer, f func(i int, gs *agonesv1.GameServer)) {
    for i, gs := range list {
        f(i, gs)
    }
}

# GKE/EKS/AKS recommended configuration
apiVersion: agones.dev/v1
kind: Fleet
spec:
  scheduling: Packed
  # Enable cluster autoscaler to scale nodes down

# Bare metal recommended configuration
apiVersion: agones.dev/v1
kind: Fleet
spec:
  scheduling: Distributed
  # Spread load across all available nodes

apiVersion: agones.dev/v1
kind: Fleet
spec:
  scheduling: Packed
  template:
    spec:
      template:
        spec:
          affinity:
            nodeAffinity:
              requiredDuringSchedulingIgnoredDuringExecution:
                nodeSelectorTerms:
                - matchExpressions:
                  - key: agones.dev/gameserver
                    operator: In
                    values:
                    - "true"

# Prometheus queries

# Average game servers per node
avg(agones_gameservers_node_count) by (node)

# Node utilization distribution
histogram_quantile(0.95, 
  sum(rate(agones_gameservers_node_count[5m])) by (le)
)

# Allocation latency by strategy
avg(allocation_duration_seconds) by (scheduling_strategy)

# Update Fleet
kubectl patch fleet my-fleet -p '{"spec":{"scheduling":"Distributed"}}'

# Trigger recreation (if needed)
kubectl scale fleet my-fleet --replicas=0
kubectl scale fleet my-fleet --replicas=100