diff --git a/install/helm/agones/templates/crds/_gameserverspecschema.yaml b/install/helm/agones/templates/crds/_gameserverspecschema.yaml
index 09c1131e9f..03cd5db3fe 100644
--- a/install/helm/agones/templates/crds/_gameserverspecschema.yaml
+++ b/install/helm/agones/templates/crds/_gameserverspecschema.yaml
@@ -154,6 +154,21 @@ properties:
             title: The initial player capacity of this Game Server
             minimum: 0
 {{- if .featureSafeToEvict }}
+      eviction:
+        type: object
+        title: Eviction tolerance of the game server
+        properties:
+          safe:
+            type: string
+            title: Game server supports termination via SIGTERM
+            description: |
+              - Never: The game server should run to completion. Agones sets Pod annotation `cluster-autoscaler.kubernetes.io/safe-to-evict: "false"` and label `agones.dev/safe-to-evict: "false"`, which matches a restrictive PodDisruptionBudget.
+              - OnUpgrade: On SIGTERM, the game server will exit within `terminationGracePeriodSeconds` or be terminated; Agones sets Pod annotation `cluster-autoscaler.kubernetes.io/safe-to-evict: "false"`, which blocks evictions by Cluster Autoscaler. Evictions from node upgrades proceed normally.
+              - Always: On SIGTERM, the game server will exit within `terminationGracePeriodSeconds` or be terminated, typically within 10m; Agones sets Pod annotation `cluster-autoscaler.kubernetes.io/safe-to-evict: "true"`, which allows evictions by Cluster Autoscaler.
+            enum:
+            - Always
+            - OnUpgrade
+            - Never
       immutableReplicas:
         type: integer
         title: Immutable count of Pods to a GameServer. Always 1. (Implementation detail of implementing the Scale subresource.)
diff --git a/install/helm/agones/templates/crds/_gameserverstatus.yaml b/install/helm/agones/templates/crds/_gameserverstatus.yaml
index 3d77aced52..f15f0db753 100644
--- a/install/helm/agones/templates/crds/_gameserverstatus.yaml
+++ b/install/helm/agones/templates/crds/_gameserverstatus.yaml
@@ -66,6 +66,15 @@ status:
           items:
             type: string
 {{- if .featureSafeToEvict }}
+    eviction:
+      type: object
+      properties:
+        safe:
+          type: string
+          enum:
+          - Always
+          - OnUpgrade
+          - Never
     immutableReplicas:
       type: integer
       title: Immutable count of Pods to a GameServer. Always 1. (Implementation detail of implementing the Scale subresource.)
diff --git a/pkg/apis/agones/v1/apihooks.go b/pkg/apis/agones/v1/apihooks.go
index 04bad0e75b..5bb65d9203 100644
--- a/pkg/apis/agones/v1/apihooks.go
+++ b/pkg/apis/agones/v1/apihooks.go
@@ -15,6 +15,8 @@
 package v1
 
 import (
+	"agones.dev/agones/pkg/util/runtime"
+	"github.com/pkg/errors"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
@@ -28,6 +30,9 @@ type APIHooks interface {
 
 	// MutateGameServerPodSpec is called by createGameServerPod to allow for product specific pod mutation.
 	MutateGameServerPodSpec(*GameServerSpec, *corev1.PodSpec) error
+
+	// SetEviction is called by gs.Pod to enforce GameServer.Status.Eviction.
+	SetEviction(EvictionSafe, *corev1.Pod) error
 }
 
 var apiHooks APIHooks = generic{}
@@ -45,3 +50,37 @@ type generic struct{}
 
 func (generic) ValidateGameServerSpec(*GameServerSpec) []metav1.StatusCause    { return nil }
 func (generic) MutateGameServerPodSpec(*GameServerSpec, *corev1.PodSpec) error { return nil }
+
+// SetEviction sets disruptions controls based on GameServer.Status.Eviction.
+func (generic) SetEviction(safe EvictionSafe, pod *corev1.Pod) error {
+	if !runtime.FeatureEnabled(runtime.FeatureSafeToEvict) {
+		return nil
+	}
+	if _, exists := pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation]; !exists {
+		switch safe {
+		case EvictionSafeAlways:
+			pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation] = True
+		case EvictionSafeOnUpgrade, EvictionSafeNever:
+			// For EvictionSafeOnUpgrade and EvictionSafeNever, we block Cluster Autoscaler.
+			pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation] = False
+		default:
+			return errors.Errorf("unknown eviction.safe value %q", string(safe))
+		}
+	}
+	if _, exists := pod.ObjectMeta.Labels[SafeToEvictLabel]; !exists {
+		switch safe {
+		case EvictionSafeAlways, EvictionSafeOnUpgrade:
+			// For EvictionSafeAlways and EvictionSafeOnUpgrade, we use a label value
+			// that does not match the agones-gameserver-safe-to-evict-false PDB. But
+			// we go ahead and label it, in case someone wants to adopt custom logic
+			// for this group of game servers.
+			pod.ObjectMeta.Labels[SafeToEvictLabel] = True
+		case EvictionSafeNever:
+			// For EvictionSafeNever, match gones-gameserver-safe-to-evict-false PDB.
+			pod.ObjectMeta.Labels[SafeToEvictLabel] = False
+		default:
+			return errors.Errorf("unknown eviction.safe value %q", string(safe))
+		}
+	}
+	return nil
+}
diff --git a/pkg/apis/agones/v1/apihooks_test.go b/pkg/apis/agones/v1/apihooks_test.go
new file mode 100644
index 0000000000..ef89b1730b
--- /dev/null
+++ b/pkg/apis/agones/v1/apihooks_test.go
@@ -0,0 +1,123 @@
+// Copyright 2022 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.
+
+package v1
+
+import (
+	"testing"
+
+	"agones.dev/agones/pkg/util/runtime"
+	"github.com/stretchr/testify/assert"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+func TestSetEviction(t *testing.T) {
+	runtime.FeatureTestMutex.Lock()
+	defer runtime.FeatureTestMutex.Unlock()
+
+	emptyPodAnd := func(f func(*corev1.Pod)) *corev1.Pod {
+		pod := &corev1.Pod{
+			ObjectMeta: metav1.ObjectMeta{
+				Annotations: map[string]string{},
+				Labels:      map[string]string{},
+			},
+		}
+		f(pod)
+		return pod
+	}
+	for desc, tc := range map[string]struct {
+		featureFlags string
+		safeToEvict  EvictionSafe
+		pod          *corev1.Pod
+		wantPod      *corev1.Pod
+	}{
+		"SafeToEvict feature gate disabled => no change": {
+			featureFlags: "SafeToEvict=false",
+			// intentionally leave pod nil, it'll crash if anything's touched.
+		},
+		"SafeToEvict: Always, no incoming labels/annotations": {
+			featureFlags: "SafeToEvict=true",
+			safeToEvict:  EvictionSafeAlways,
+			pod:          emptyPodAnd(func(*corev1.Pod) {}),
+			wantPod: emptyPodAnd(func(pod *corev1.Pod) {
+				pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation] = True
+				pod.ObjectMeta.Labels[SafeToEvictLabel] = True
+			}),
+		},
+		"SafeToEvict: OnUpgrade, no incoming labels/annotations": {
+			featureFlags: "SafeToEvict=true",
+			safeToEvict:  EvictionSafeOnUpgrade,
+			pod:          emptyPodAnd(func(*corev1.Pod) {}),
+			wantPod: emptyPodAnd(func(pod *corev1.Pod) {
+				pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation] = False
+				pod.ObjectMeta.Labels[SafeToEvictLabel] = True
+			}),
+		},
+		"SafeToEvict: Never, no incoming labels/annotations": {
+			featureFlags: "SafeToEvict=true",
+			safeToEvict:  EvictionSafeNever,
+			pod:          emptyPodAnd(func(*corev1.Pod) {}),
+			wantPod: emptyPodAnd(func(pod *corev1.Pod) {
+				pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation] = False
+				pod.ObjectMeta.Labels[SafeToEvictLabel] = False
+			}),
+		},
+		"SafeToEvict: Always, incoming labels/annotations": {
+			featureFlags: "SafeToEvict=true",
+			safeToEvict:  EvictionSafeAlways,
+			pod: emptyPodAnd(func(pod *corev1.Pod) {
+				pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation] = "just don't touch, ok?"
+				pod.ObjectMeta.Labels[SafeToEvictLabel] = "seriously, leave it"
+			}),
+			wantPod: emptyPodAnd(func(pod *corev1.Pod) {
+				pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation] = "just don't touch, ok?"
+				pod.ObjectMeta.Labels[SafeToEvictLabel] = "seriously, leave it"
+			}),
+		},
+		"SafeToEvict: OnUpgrade, incoming labels/annotations": {
+			featureFlags: "SafeToEvict=true",
+			safeToEvict:  EvictionSafeOnUpgrade,
+			pod: emptyPodAnd(func(pod *corev1.Pod) {
+				pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation] = "better not touch"
+				pod.ObjectMeta.Labels[SafeToEvictLabel] = "not another one"
+			}),
+			wantPod: emptyPodAnd(func(pod *corev1.Pod) {
+				pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation] = "better not touch"
+				pod.ObjectMeta.Labels[SafeToEvictLabel] = "not another one"
+			}),
+		},
+		"SafeToEvict: Never, incoming labels/annotations": {
+			featureFlags: "SafeToEvict=true",
+			safeToEvict:  EvictionSafeNever,
+			pod: emptyPodAnd(func(pod *corev1.Pod) {
+				pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation] = "a passthrough"
+				pod.ObjectMeta.Labels[SafeToEvictLabel] = "or is it passthru?"
+			}),
+			wantPod: emptyPodAnd(func(pod *corev1.Pod) {
+				pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation] = "a passthrough"
+				pod.ObjectMeta.Labels[SafeToEvictLabel] = "or is it passthru?"
+			}),
+		},
+	} {
+		t.Run(desc, func(t *testing.T) {
+			err := runtime.ParseFeatures(tc.featureFlags)
+			assert.NoError(t, err)
+
+			err = (generic{}).SetEviction(tc.safeToEvict, tc.pod)
+			assert.NoError(t, err)
+			assert.Equal(t, tc.wantPod, tc.pod)
+		})
+	}
+}
diff --git a/pkg/apis/agones/v1/gameserver.go b/pkg/apis/agones/v1/gameserver.go
index 80d1d1ca74..3d27ad2670 100644
--- a/pkg/apis/agones/v1/gameserver.go
+++ b/pkg/apis/agones/v1/gameserver.go
@@ -72,6 +72,16 @@ const (
 	// This will mean that users will need to lookup what port has been opened through the server side SDK.
 	Passthrough PortPolicy = "Passthrough"
 
+	// EvictionSafeAlways means the game server supports termination via SIGTERM, and wants eviction signals
+	// from Cluster Autoscaler scaledown and node upgrades.
+	EvictionSafeAlways EvictionSafe = "Always"
+	// EvictionSafeOnUpgrade means the game server supports termination via SIGTERM, and wants eviction signals
+	// from node upgrades, but not Cluster Autoscaler scaledown.
+	EvictionSafeOnUpgrade EvictionSafe = "OnUpgrade"
+	// EvictionSafeNever means the game server should run to completion and may not understand SIGTERM. Eviction
+	// from ClusterAutoscaler and upgrades should both be blocked.
+	EvictionSafeNever EvictionSafe = "Never"
+
 	// ProtocolTCPUDP Protocol exposes the hostPort allocated for this container for both TCP and UDP.
 	ProtocolTCPUDP corev1.Protocol = "TCPUDP"
 
@@ -104,6 +114,13 @@ const (
 	// determine if a pod can safely be evicted to compact a cluster by moving pods between nodes
 	// and scaling down nodes.
 	PodSafeToEvictAnnotation = "cluster-autoscaler.kubernetes.io/safe-to-evict"
+	// SafeToEvictLabel is a label that, when "false", matches the restrictive PDB agones-gameserver-safe-to-evict-false.
+	SafeToEvictLabel = agones.GroupName + "/safe-to-evict"
+
+	// True is the string "true" to appease the goconst lint.
+	True = "true"
+	// False is the string "false" to appease the goconst lint.
+	False = "false"
 )
 
 var (
@@ -162,6 +179,9 @@ type GameServerSpec struct {
 	// (Alpha, PlayerTracking feature flag) Players provides the configuration for player tracking features.
 	// +optional
 	Players *PlayersSpec `json:"players,omitempty"`
+	// (Alpha, SafeToEvict feature flag) Eviction specifies the eviction tolerance of the GameServer. Defaults to "Never".
+	// +optional
+	Eviction Eviction `json:"eviction,omitempty"`
 	// immutableReplicas is present in gameservers.agones.dev but omitted here (it's always 1).
 }
 
@@ -170,12 +190,25 @@ type PlayersSpec struct {
 	InitialCapacity int64 `json:"initialCapacity,omitempty"`
 }
 
+// Eviction specifies the eviction tolerance of the GameServer
+type Eviction struct {
+	// (Alpha, SafeToEvict feature flag)
+	// Game server supports termination via SIGTERM:
+	// - Always: Allow eviction for both Cluster Autoscaler and node drain for upgrades
+	// - OnUpgrade: Allow eviction for upgrades alone
+	// - Never (default): Pod should run to completion
+	Safe EvictionSafe `json:"safe,omitempty"`
+}
+
 // GameServerState is the state for the GameServer
 type GameServerState string
 
 // PortPolicy is the port policy for the GameServer
 type PortPolicy string
 
+// EvictionSafe specified whether the game server supports termination via SIGTERM
+type EvictionSafe string
+
 // Health configures health checking on the GameServer
 type Health struct {
 	// Disabled is whether health checking is disabled or not
@@ -235,6 +268,8 @@ type GameServerStatus struct {
 	// [FeatureFlag:PlayerTracking]
 	// +optional
 	Players *PlayerStatus `json:"players"`
+	// (Alpha, SafeToEvict feature flag) Eviction specifies the eviction tolerance of the GameServer.
+	Eviction Eviction `json:"eviction,omitempty"`
 	// immutableReplicas is present in gameservers.agones.dev but omitted here (it's always 1).
 }
 
@@ -271,6 +306,7 @@ func (gss *GameServerSpec) ApplyDefaults() {
 	gss.applyContainerDefaults()
 	gss.applyPortDefaults()
 	gss.applyHealthDefaults()
+	gss.applyEvictionDefaults()
 	gss.applySchedulingDefaults()
 	gss.applySdkServerDefaults()
 }
@@ -330,6 +366,8 @@ func (gs *GameServer) applyStatusDefaults() {
 			gs.Status.Players.Capacity = gs.Spec.Players.InitialCapacity
 		}
 	}
+
+	gs.applyEvictionStatus()
 }
 
 // applyPortDefaults applies default values for all ports
@@ -356,6 +394,25 @@ func (gss *GameServerSpec) applySchedulingDefaults() {
 	}
 }
 
+func (gss *GameServerSpec) applyEvictionDefaults() {
+	if !runtime.FeatureEnabled(runtime.FeatureSafeToEvict) {
+		return
+	}
+	if gss.Eviction.Safe == "" {
+		gss.Eviction.Safe = EvictionSafeNever
+	}
+}
+
+func (gs *GameServer) applyEvictionStatus() {
+	if !runtime.FeatureEnabled(runtime.FeatureSafeToEvict) {
+		return
+	}
+	gs.Status.Eviction = gs.Spec.Eviction
+	if gs.Spec.Template.ObjectMeta.Annotations[PodSafeToEvictAnnotation] == "true" {
+		gs.Status.Eviction.Safe = EvictionSafeAlways
+	}
+}
+
 // Validate validates the GameServerSpec configuration.
 // devAddress is a specific IP address used for local Gameservers, for fleets "" is used
 // If a GameServer Spec is invalid there will be > 0 values in
@@ -373,6 +430,16 @@ func (gss *GameServerSpec) Validate(devAddress string) ([]metav1.StatusCause, bo
 		}
 	}
 
+	if !runtime.FeatureEnabled(runtime.FeatureSafeToEvict) {
+		if gss.Eviction.Safe != "" {
+			causes = append(causes, metav1.StatusCause{
+				Type:    metav1.CauseTypeFieldValueNotSupported,
+				Field:   "eviction.safe",
+				Message: fmt.Sprintf("Value cannot be set unless feature flag %s is enabled", runtime.FeatureSafeToEvict),
+			})
+		}
+	}
+
 	if devAddress != "" {
 		// verify that the value is a valid IP address.
 		if net.ParseIP(devAddress) == nil {
@@ -631,6 +698,9 @@ func (gs *GameServer) Pod(sidecars ...corev1.Container) (*corev1.Pod, error) {
 	if err := apiHooks.MutateGameServerPodSpec(&gs.Spec, &pod.Spec); err != nil {
 		return nil, err
 	}
+	if err := apiHooks.SetEviction(gs.Status.Eviction.Safe, pod); err != nil {
+		return nil, err
+	}
 
 	return pod, nil
 }
@@ -660,13 +730,16 @@ func (gs *GameServer) podObjectMeta(pod *corev1.Pod) {
 	ref := metav1.NewControllerRef(gs, SchemeGroupVersion.WithKind("GameServer"))
 	pod.ObjectMeta.OwnerReferences = append(pod.ObjectMeta.OwnerReferences, *ref)
 
-	// This means that the autoscaler cannot remove the Node that this Pod is on.
-	// (and evict the Pod in the process). Only set the value if it has not already
-	// been configured in the pod template (to not override user specified behavior).
-	// We only set this for packed game servers, under the assumption that if
-	// game servers are distributed then the cluster autoscaler isn't likely running.
-	if _, exists := pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation]; !exists && gs.Spec.Scheduling == apis.Packed {
-		pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation] = "false"
+	// When SafeToEvict=true, apiHooks.SetEviction manages disruption controls.
+	if !runtime.FeatureEnabled(runtime.FeatureSafeToEvict) {
+		// This means that the autoscaler cannot remove the Node that this Pod is on.
+		// (and evict the Pod in the process). Only set the value if it has not already
+		// been configured in the pod template (to not override user specified behavior).
+		// We only set this for packed game servers, under the assumption that if
+		// game servers are distributed then the cluster autoscaler isn't likely running.
+		if _, exists := pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation]; !exists && gs.Spec.Scheduling == apis.Packed {
+			pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation] = "false"
+		}
 	}
 
 	// Add Agones version into Pod Annotations
diff --git a/pkg/apis/agones/v1/gameserver_test.go b/pkg/apis/agones/v1/gameserver_test.go
index 01cd27973c..b6f7534f08 100644
--- a/pkg/apis/agones/v1/gameserver_test.go
+++ b/pkg/apis/agones/v1/gameserver_test.go
@@ -134,7 +134,20 @@ func TestGameServerApplyDefaults(t *testing.T) {
 
 	ten := int64(10)
 
+	defaultGameServerAnd := func(f func(gss *GameServerSpec)) GameServer {
+		gs := GameServer{
+			Spec: GameServerSpec{
+				Ports: []GameServerPort{{ContainerPort: 999}},
+				Template: corev1.PodTemplateSpec{
+					Spec: corev1.PodSpec{Containers: []corev1.Container{
+						{Name: "testing", Image: "testing/image"},
+					}}}},
+		}
+		f(&gs.Spec)
+		return gs
+	}
 	type expected struct {
+		container           string
 		protocol            corev1.Protocol
 		state               GameServerState
 		policy              PortPolicy
@@ -142,6 +155,30 @@ func TestGameServerApplyDefaults(t *testing.T) {
 		scheduling          apis.SchedulingStrategy
 		sdkServer           SdkServer
 		alphaPlayerCapacity *int64
+		evictionSafeSpec    EvictionSafe
+		evictionSafeStatus  EvictionSafe
+	}
+	wantDefaultAnd := func(f func(e *expected)) expected {
+		e := expected{
+			container:  "testing",
+			protocol:   "UDP",
+			state:      GameServerStatePortAllocation,
+			policy:     Dynamic,
+			scheduling: apis.Packed,
+			health: Health{
+				Disabled:            false,
+				FailureThreshold:    3,
+				InitialDelaySeconds: 5,
+				PeriodSeconds:       5,
+			},
+			sdkServer: SdkServer{
+				LogLevel: SdkServerLogLevelInfo,
+				GRPCPort: 9357,
+				HTTPPort: 9358,
+			},
+		}
+		f(&e)
+		return e
 	}
 	data := map[string]struct {
 		gameServer   GameServer
@@ -150,63 +187,25 @@ func TestGameServerApplyDefaults(t *testing.T) {
 		expected     expected
 	}{
 		"set basic defaults on a very simple gameserver": {
+			gameServer: defaultGameServerAnd(func(gss *GameServerSpec) {}),
+			expected:   wantDefaultAnd(func(e *expected) {}),
+		},
+		"PlayerTracking=true": {
 			featureFlags: string(runtime.FeaturePlayerTracking) + "=true",
-			gameServer: GameServer{
-				Spec: GameServerSpec{
-					Players: &PlayersSpec{InitialCapacity: 10},
-					Ports:   []GameServerPort{{ContainerPort: 999}},
-					Template: corev1.PodTemplateSpec{
-						Spec: corev1.PodSpec{Containers: []corev1.Container{
-							{Name: "testing", Image: "testing/image"},
-						}}}},
-			},
-			container: "testing",
-			expected: expected{
-				protocol:   "UDP",
-				state:      GameServerStatePortAllocation,
-				policy:     Dynamic,
-				scheduling: apis.Packed,
-				health: Health{
-					Disabled:            false,
-					FailureThreshold:    3,
-					InitialDelaySeconds: 5,
-					PeriodSeconds:       5,
-				},
-				sdkServer: SdkServer{
-					LogLevel: SdkServerLogLevelInfo,
-					GRPCPort: 9357,
-					HTTPPort: 9358,
-				},
-				alphaPlayerCapacity: &ten,
-			},
+			gameServer: defaultGameServerAnd(func(gss *GameServerSpec) {
+				gss.Players = &PlayersSpec{InitialCapacity: 10}
+			}),
+			expected: wantDefaultAnd(func(e *expected) {
+				e.alphaPlayerCapacity = &ten
+			}),
 		},
 		"defaults on passthrough": {
-			gameServer: GameServer{
-				Spec: GameServerSpec{
-					Ports: []GameServerPort{{PortPolicy: Passthrough}},
-					Template: corev1.PodTemplateSpec{
-						Spec: corev1.PodSpec{Containers: []corev1.Container{
-							{Name: "testing", Image: "testing/image"},
-						}}}},
-			},
-			container: "testing",
-			expected: expected{
-				protocol:   "UDP",
-				state:      GameServerStatePortAllocation,
-				policy:     Passthrough,
-				scheduling: apis.Packed,
-				health: Health{
-					Disabled:            false,
-					FailureThreshold:    3,
-					InitialDelaySeconds: 5,
-					PeriodSeconds:       5,
-				},
-				sdkServer: SdkServer{
-					LogLevel: SdkServerLogLevelInfo,
-					GRPCPort: 9357,
-					HTTPPort: 9358,
-				},
-			},
+			gameServer: defaultGameServerAnd(func(gss *GameServerSpec) {
+				gss.Ports[0].PortPolicy = Passthrough
+			}),
+			expected: wantDefaultAnd(func(e *expected) {
+				e.policy = Passthrough
+			}),
 		},
 		"defaults are already set": {
 			gameServer: GameServer{
@@ -235,165 +234,146 @@ func TestGameServerApplyDefaults(t *testing.T) {
 					},
 				},
 				Status: GameServerStatus{State: "TestState"}},
-			container: "testing2",
-			expected: expected{
-				protocol:   "TCP",
-				state:      "TestState",
-				policy:     Static,
-				scheduling: apis.Packed,
-				health: Health{
+			expected: wantDefaultAnd(func(e *expected) {
+				e.container = "testing2"
+				e.protocol = "TCP"
+				e.state = "TestState"
+				e.health = Health{
 					Disabled:            false,
 					FailureThreshold:    10,
 					InitialDelaySeconds: 11,
 					PeriodSeconds:       12,
-				},
-				sdkServer: SdkServer{
-					LogLevel: SdkServerLogLevelInfo,
-					GRPCPort: 9357,
-					HTTPPort: 9358,
-				},
-			},
+				}
+			}),
 		},
 		"set basic defaults on static gameserver": {
-			gameServer: GameServer{
-				Spec: GameServerSpec{
-					Ports: []GameServerPort{{PortPolicy: Static}},
-					Template: corev1.PodTemplateSpec{
-						Spec: corev1.PodSpec{Containers: []corev1.Container{{Name: "testing", Image: "testing/image"}}}}},
-			},
-			container: "testing",
-			expected: expected{
-				protocol:   "UDP",
-				state:      GameServerStateCreating,
-				policy:     Static,
-				scheduling: apis.Packed,
-				health: Health{
-					Disabled:            false,
-					FailureThreshold:    3,
-					InitialDelaySeconds: 5,
-					PeriodSeconds:       5,
-				},
-				sdkServer: SdkServer{
-					LogLevel: SdkServerLogLevelInfo,
-					GRPCPort: 9357,
-					HTTPPort: 9358,
-				},
-			},
+			gameServer: defaultGameServerAnd(func(gss *GameServerSpec) {
+				gss.Ports[0].PortPolicy = Static
+			}),
+			expected: wantDefaultAnd(func(e *expected) {
+				e.state = GameServerStateCreating
+				e.policy = Static
+			}),
 		},
 		"health is disabled": {
-			gameServer: GameServer{
-				Spec: GameServerSpec{
-					Ports:  []GameServerPort{{ContainerPort: 999}},
-					Health: Health{Disabled: true},
-					Template: corev1.PodTemplateSpec{
-						Spec: corev1.PodSpec{Containers: []corev1.Container{{Name: "testing", Image: "testing/image"}}}}},
-			},
-			container: "testing",
-			expected: expected{
-				protocol:   "UDP",
-				state:      GameServerStatePortAllocation,
-				policy:     Dynamic,
-				scheduling: apis.Packed,
-				health: Health{
-					Disabled: true,
-				},
-				sdkServer: SdkServer{
-					LogLevel: SdkServerLogLevelInfo,
-					GRPCPort: 9357,
-					HTTPPort: 9358,
-				},
-			},
+			gameServer: defaultGameServerAnd(func(gss *GameServerSpec) {
+				gss.Health = Health{Disabled: true}
+			}),
+			expected: wantDefaultAnd(func(e *expected) {
+				e.health = Health{Disabled: true}
+			}),
 		},
 		"convert from legacy single port to multiple": {
-			gameServer: GameServer{
-				Spec: GameServerSpec{
-					Ports: []GameServerPort{
-						{
-							ContainerPort: 777,
-							HostPort:      777,
-							PortPolicy:    Static,
-							Protocol:      corev1.ProtocolTCP,
-						},
-					},
-					Health: Health{Disabled: true},
-					Template: corev1.PodTemplateSpec{
-						Spec: corev1.PodSpec{Containers: []corev1.Container{{Name: "testing", Image: "testing/image"}}}}},
-			},
-			container: "testing",
-			expected: expected{
-				protocol:   corev1.ProtocolTCP,
-				state:      GameServerStateCreating,
-				policy:     Static,
-				scheduling: apis.Packed,
-				health:     Health{Disabled: true},
-				sdkServer: SdkServer{
-					LogLevel: SdkServerLogLevelInfo,
-					GRPCPort: 9357,
-					HTTPPort: 9358,
-				},
-			},
+			gameServer: defaultGameServerAnd(func(gss *GameServerSpec) {
+				gss.Ports[0] = GameServerPort{
+					ContainerPort: 777,
+					HostPort:      777,
+					PortPolicy:    Static,
+					Protocol:      corev1.ProtocolTCP,
+				}
+			}),
+			expected: wantDefaultAnd(func(e *expected) {
+				e.protocol = "TCP"
+				e.state = GameServerStateCreating
+			}),
 		},
 		"set Debug logging level": {
-			gameServer: GameServer{
-				Spec: GameServerSpec{
-					Ports:     []GameServerPort{{ContainerPort: 999}},
-					SdkServer: SdkServer{LogLevel: SdkServerLogLevelDebug},
-					Template: corev1.PodTemplateSpec{
-						Spec: corev1.PodSpec{Containers: []corev1.Container{
-							{Name: "testing", Image: "testing/image"},
-						}}}},
-			},
-			container: "testing",
-			expected: expected{
-				protocol:   "UDP",
-				state:      GameServerStatePortAllocation,
-				policy:     Dynamic,
-				scheduling: apis.Packed,
-				health: Health{
-					Disabled:            false,
-					FailureThreshold:    3,
-					InitialDelaySeconds: 5,
-					PeriodSeconds:       5,
-				},
-				sdkServer: SdkServer{
-					LogLevel: SdkServerLogLevelDebug,
-					GRPCPort: 9357,
-					HTTPPort: 9358,
-				},
-			},
+			gameServer: defaultGameServerAnd(func(gss *GameServerSpec) {
+				gss.SdkServer = SdkServer{LogLevel: SdkServerLogLevelDebug}
+			}),
+			expected: wantDefaultAnd(func(e *expected) {
+				e.sdkServer.LogLevel = SdkServerLogLevelDebug
+			}),
 		},
 		"set gRPC and HTTP ports on SDK Server": {
-			gameServer: GameServer{
-				Spec: GameServerSpec{
-					Ports: []GameServerPort{{ContainerPort: 999}},
-					SdkServer: SdkServer{
-						LogLevel: SdkServerLogLevelError,
-						GRPCPort: 19357,
-						HTTPPort: 19358,
-					},
-					Template: corev1.PodTemplateSpec{
-						Spec: corev1.PodSpec{Containers: []corev1.Container{
-							{Name: "testing", Image: "testing/image"},
-						}}}},
-			},
-			container: "testing",
-			expected: expected{
-				protocol:   "UDP",
-				state:      GameServerStatePortAllocation,
-				policy:     Dynamic,
-				scheduling: apis.Packed,
-				health: Health{
-					Disabled:            false,
-					FailureThreshold:    3,
-					InitialDelaySeconds: 5,
-					PeriodSeconds:       5,
-				},
-				sdkServer: SdkServer{
+			gameServer: defaultGameServerAnd(func(gss *GameServerSpec) {
+				gss.SdkServer = SdkServer{
 					LogLevel: SdkServerLogLevelError,
 					GRPCPort: 19357,
 					HTTPPort: 19358,
-				},
-			},
+				}
+			}),
+			expected: wantDefaultAnd(func(e *expected) {
+				e.sdkServer = SdkServer{
+					LogLevel: SdkServerLogLevelError,
+					GRPCPort: 19357,
+					HTTPPort: 19358,
+				}
+			}),
+		},
+		"SafeToEvict gate off => no SafeToEvict fields": {
+			featureFlags: string(runtime.FeatureSafeToEvict) + "=false",
+			gameServer:   defaultGameServerAnd(func(gss *GameServerSpec) {}),
+			expected:     wantDefaultAnd(func(e *expected) {}),
+		},
+		"SafeToEvict gate on => SafeToEvict: Never": {
+			featureFlags: string(runtime.FeatureSafeToEvict) + "=true",
+			gameServer:   defaultGameServerAnd(func(gss *GameServerSpec) {}),
+			expected: wantDefaultAnd(func(e *expected) {
+				e.evictionSafeSpec = EvictionSafeNever
+				e.evictionSafeStatus = EvictionSafeNever
+			}),
+		},
+		"SafeToEvict: Always": {
+			featureFlags: string(runtime.FeatureSafeToEvict) + "=true",
+			gameServer: defaultGameServerAnd(func(gss *GameServerSpec) {
+				gss.Eviction.Safe = EvictionSafeAlways
+			}),
+			expected: wantDefaultAnd(func(e *expected) {
+				e.evictionSafeSpec = EvictionSafeAlways
+				e.evictionSafeStatus = EvictionSafeAlways
+			}),
+		},
+		"SafeToEvict: OnUpgrade": {
+			featureFlags: string(runtime.FeatureSafeToEvict) + "=true",
+			gameServer: defaultGameServerAnd(func(gss *GameServerSpec) {
+				gss.Eviction.Safe = EvictionSafeOnUpgrade
+			}),
+			expected: wantDefaultAnd(func(e *expected) {
+				e.evictionSafeSpec = EvictionSafeOnUpgrade
+				e.evictionSafeStatus = EvictionSafeOnUpgrade
+			}),
+		},
+		"SafeToEvict: Never": {
+			featureFlags: string(runtime.FeatureSafeToEvict) + "=true",
+			gameServer: defaultGameServerAnd(func(gss *GameServerSpec) {
+				gss.Eviction.Safe = EvictionSafeNever
+			}),
+			expected: wantDefaultAnd(func(e *expected) {
+				e.evictionSafeSpec = EvictionSafeNever
+				e.evictionSafeStatus = EvictionSafeNever
+			}),
+		},
+		"SafeToEvict: Always inferred from safe-to-evict=true": {
+			featureFlags: string(runtime.FeatureSafeToEvict) + "=true",
+			gameServer: defaultGameServerAnd(func(gss *GameServerSpec) {
+				gss.Template.ObjectMeta.Annotations = map[string]string{PodSafeToEvictAnnotation: "true"}
+			}),
+			expected: wantDefaultAnd(func(e *expected) {
+				e.evictionSafeSpec = EvictionSafeNever
+				e.evictionSafeStatus = EvictionSafeAlways
+			}),
+		},
+		"Nothing inferred from safe-to-evict=false": {
+			featureFlags: string(runtime.FeatureSafeToEvict) + "=true",
+			gameServer: defaultGameServerAnd(func(gss *GameServerSpec) {
+				gss.Template.ObjectMeta.Annotations = map[string]string{PodSafeToEvictAnnotation: "false"}
+			}),
+			expected: wantDefaultAnd(func(e *expected) {
+				e.evictionSafeSpec = EvictionSafeNever
+				e.evictionSafeStatus = EvictionSafeNever
+			}),
+		},
+		"safe-to-evict=false AND SafeToEvict: Always => SafeToEvict: Always": {
+			featureFlags: string(runtime.FeatureSafeToEvict) + "=true",
+			gameServer: defaultGameServerAnd(func(gss *GameServerSpec) {
+				gss.Eviction.Safe = EvictionSafeAlways
+				gss.Template.ObjectMeta.Annotations = map[string]string{PodSafeToEvictAnnotation: "false"}
+			}),
+			expected: wantDefaultAnd(func(e *expected) {
+				e.evictionSafeSpec = EvictionSafeAlways
+				e.evictionSafeStatus = EvictionSafeAlways
+			}),
 		},
 	}
 
@@ -411,7 +391,7 @@ func TestGameServerApplyDefaults(t *testing.T) {
 
 			spec := test.gameServer.Spec
 			assert.Contains(t, test.gameServer.ObjectMeta.Finalizers, agones.GroupName)
-			assert.Equal(t, test.container, spec.Container)
+			assert.Equal(t, test.expected.container, spec.Container)
 			assert.Equal(t, test.expected.protocol, spec.Ports[0].Protocol)
 			assert.Equal(t, test.expected.state, test.gameServer.Status.State)
 			assert.Equal(t, test.expected.scheduling, test.gameServer.Spec.Scheduling)
@@ -423,6 +403,8 @@ func TestGameServerApplyDefaults(t *testing.T) {
 				assert.Nil(t, test.gameServer.Spec.Players)
 				assert.Nil(t, test.gameServer.Status.Players)
 			}
+			assert.Equal(t, test.expected.evictionSafeSpec, spec.Eviction.Safe)
+			assert.Equal(t, test.expected.evictionSafeStatus, test.gameServer.Status.Eviction.Safe)
 		})
 	}
 }
@@ -1265,67 +1247,116 @@ func TestGameServerPodWithMultiplePortAllocations(t *testing.T) {
 }
 
 func TestGameServerPodObjectMeta(t *testing.T) {
+	runtime.FeatureTestMutex.Lock()
+	defer runtime.FeatureTestMutex.Unlock()
+
 	fixture := &GameServer{ObjectMeta: metav1.ObjectMeta{Name: "lucy"},
 		Spec: GameServerSpec{Container: "goat"}}
 
-	f := func(t *testing.T, gs *GameServer, pod *corev1.Pod) {
-		assert.Equal(t, gs.ObjectMeta.Name, pod.ObjectMeta.Name)
-		assert.Equal(t, gs.ObjectMeta.Namespace, pod.ObjectMeta.Namespace)
-		assert.Equal(t, GameServerLabelRole, pod.ObjectMeta.Labels[RoleLabel])
-		assert.Equal(t, "gameserver", pod.ObjectMeta.Labels[agones.GroupName+"/role"])
-		assert.Equal(t, gs.ObjectMeta.Name, pod.ObjectMeta.Labels[GameServerPodLabel])
-		assert.Equal(t, "goat", pod.ObjectMeta.Annotations[GameServerContainerAnnotation])
-		assert.True(t, metav1.IsControlledBy(pod, gs))
-	}
-
-	t.Run("packed", func(t *testing.T) {
-		gs := fixture.DeepCopy()
-		gs.Spec.Scheduling = apis.Packed
-		pod := &corev1.Pod{}
-
-		gs.podObjectMeta(pod)
-		f(t, gs, pod)
-
-		assert.Equal(t, "false", pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation])
-	})
+	for desc, tc := range map[string]struct {
+		featureFlags string
+		scheduling   apis.SchedulingStrategy
+		wantSafe     string
+	}{
+		"packed, SafeToEvict=false": {
+			featureFlags: "SafeToEvict=false",
+			scheduling:   apis.Packed,
+			wantSafe:     "false",
+		},
+		"distributed, SafeToEvict=false": {
+			featureFlags: "SafeToEvict=false",
+			scheduling:   apis.Distributed,
+		},
+		"packed, SafeToEvict=true": {
+			featureFlags: "SafeToEvict=true",
+			scheduling:   apis.Packed,
+		},
+		"distributed, SafeToEvict=true": {
+			featureFlags: "SafeToEvict=true",
+			scheduling:   apis.Distributed,
+		},
+	} {
+		t.Run(desc, func(t *testing.T) {
+			err := runtime.ParseFeatures(tc.featureFlags)
+			assert.NoError(t, err)
 
-	t.Run("distributed", func(t *testing.T) {
-		gs := fixture.DeepCopy()
-		gs.Spec.Scheduling = apis.Distributed
-		pod := &corev1.Pod{}
+			gs := fixture.DeepCopy()
+			gs.Spec.Scheduling = tc.scheduling
+			pod := &corev1.Pod{}
 
-		gs.podObjectMeta(pod)
-		f(t, gs, pod)
+			gs.podObjectMeta(pod)
 
-		assert.Equal(t, "", pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation])
-	})
+			assert.Equal(t, gs.ObjectMeta.Name, pod.ObjectMeta.Name)
+			assert.Equal(t, gs.ObjectMeta.Namespace, pod.ObjectMeta.Namespace)
+			assert.Equal(t, GameServerLabelRole, pod.ObjectMeta.Labels[RoleLabel])
+			assert.Equal(t, "gameserver", pod.ObjectMeta.Labels[agones.GroupName+"/role"])
+			assert.Equal(t, gs.ObjectMeta.Name, pod.ObjectMeta.Labels[GameServerPodLabel])
+			assert.Equal(t, "goat", pod.ObjectMeta.Annotations[GameServerContainerAnnotation])
+			assert.True(t, metav1.IsControlledBy(pod, gs))
+			assert.Equal(t, tc.wantSafe, pod.ObjectMeta.Annotations[PodSafeToEvictAnnotation])
+		})
+	}
 }
 
 func TestGameServerPodAutoscalerAnnotations(t *testing.T) {
+	runtime.FeatureTestMutex.Lock()
+	defer runtime.FeatureTestMutex.Unlock()
+
 	testCases := []struct {
+		featureFlags       string
 		description        string
 		scheduling         apis.SchedulingStrategy
 		setAnnotation      bool
 		expectedAnnotation string
 	}{
 		{
-			description:        "Packed",
+			featureFlags:       "SafeToEvict=false",
+			description:        "Packed, SafeToEvict=false",
 			scheduling:         apis.Packed,
 			expectedAnnotation: "false",
 		},
 		{
-			description:        "Distributed",
+			featureFlags:       "SafeToEvict=false",
+			description:        "Distributed, SafeToEvict=false",
 			scheduling:         apis.Distributed,
 			expectedAnnotation: "",
 		},
 		{
-			description:        "Packed with autoscaler annotation",
+			featureFlags:       "SafeToEvict=false",
+			description:        "Packed with autoscaler annotation, SafeToEvict=false",
 			scheduling:         apis.Packed,
 			setAnnotation:      true,
 			expectedAnnotation: "true",
 		},
 		{
-			description:        "Distributed with autoscaler annotation",
+			featureFlags:       "SafeToEvict=false",
+			description:        "Distributed with autoscaler annotation, SafeToEvict=false",
+			scheduling:         apis.Distributed,
+			setAnnotation:      true,
+			expectedAnnotation: "true",
+		},
+		{
+			featureFlags:       "SafeToEvict=true",
+			description:        "Packed, SafeToEvict=true",
+			scheduling:         apis.Packed,
+			expectedAnnotation: "false",
+		},
+		{
+			featureFlags:       "SafeToEvict=true",
+			description:        "Distributed, SafeToEvict=true",
+			scheduling:         apis.Distributed,
+			expectedAnnotation: "false",
+		},
+		{
+			featureFlags:       "SafeToEvict=true",
+			description:        "Packed with autoscaler annotation, SafeToEvict=true",
+			scheduling:         apis.Packed,
+			setAnnotation:      true,
+			expectedAnnotation: "true",
+		},
+		{
+			featureFlags:       "SafeToEvict=true",
+			description:        "Distributed with autoscaler annotation, SafeToEvict=true",
 			scheduling:         apis.Distributed,
 			setAnnotation:      true,
 			expectedAnnotation: "true",
@@ -1335,9 +1366,13 @@ func TestGameServerPodAutoscalerAnnotations(t *testing.T) {
 	fixture := &GameServer{
 		ObjectMeta: metav1.ObjectMeta{Name: "logan"},
 		Spec:       GameServerSpec{Container: "sheep"},
+		Status:     GameServerStatus{Eviction: Eviction{Safe: EvictionSafeNever}},
 	}
 	for _, tc := range testCases {
 		t.Run(tc.description, func(t *testing.T) {
+			err := runtime.ParseFeatures(tc.featureFlags)
+			assert.NoError(t, err)
+
 			gs := fixture.DeepCopy()
 			gs.Spec.Scheduling = tc.scheduling
 			if tc.setAnnotation {
diff --git a/pkg/cloudproduct/gke/gke.go b/pkg/cloudproduct/gke/gke.go
index fce5ec8346..bbd9169b76 100644
--- a/pkg/cloudproduct/gke/gke.go
+++ b/pkg/cloudproduct/gke/gke.go
@@ -38,8 +38,9 @@ const (
 	noWorkloadDefaulter          = "failed to get MutatingWebhookConfigurations/workload-defaulter.config.common-webhooks.networking.gke.io (error expected if not on GKE Autopilot)"
 	hostPortAssignmentAnnotation = "autopilot.gke.io/host-port-assignment"
 
-	errPortPolicyMustBeDynamic = "PortPolicy must be Dynamic on GKE Autopilot"
-	errSchedulingMustBePacked  = "Scheduling strategy must be Packed on GKE Autopilot"
+	errPortPolicyMustBeDynamic      = "portPolicy must be Dynamic on GKE Autopilot"
+	errSchedulingMustBePacked       = "scheduling strategy must be Packed on GKE Autopilot"
+	errEvictionSafeOnUpgradeInvalid = "eviction.safe OnUpgrade not supported on GKE Autopilot"
 )
 
 var logger = runtime.NewLoggerWithSource("gke")
@@ -127,6 +128,14 @@ func (*gkeAutopilot) ValidateGameServerSpec(gss *agonesv1.GameServerSpec) []meta
 			Message: errSchedulingMustBePacked,
 		})
 	}
+	// See SetEviction comment below for why we block EvictionSafeOnUpgrade.
+	if gss.Eviction.Safe == agonesv1.EvictionSafeOnUpgrade {
+		causes = append(causes, metav1.StatusCause{
+			Type:    metav1.CauseTypeFieldValueInvalid,
+			Field:   "eviction.safe",
+			Message: errEvictionSafeOnUpgradeInvalid,
+		})
+	}
 	return causes
 }
 
@@ -149,6 +158,37 @@ func podSpecSeccompUnconfined(podSpec *corev1.PodSpec) {
 	podSpec.SecurityContext.SeccompProfile = &corev1.SeccompProfile{Type: corev1.SeccompProfileTypeUnconfined}
 }
 
+// SetEviction sets disruption controls based on GameServer.Status.Eviction. For Autopilot:
+//   - Since the safe-to-evict pod annotation is not supported if "false", we delete it (if it's set
+//     to anything else, we allow it - Autopilot only rejects "false").
+//   - OnUpgrade is not supported and rejected by validation above. Since we can't support
+//     safe-to-evict=false but can support a restrictive PDB, we can support Never and Always, but
+//     OnUpgrade doesn't make sense on Autopilot today. - an overly restrictive PDB prevents
+//     any sort of graceful eviction.
+func (*gkeAutopilot) SetEviction(safe agonesv1.EvictionSafe, pod *corev1.Pod) error {
+	if !runtime.FeatureEnabled(runtime.FeatureSafeToEvict) {
+		return nil
+	}
+	if safeAnnotation := pod.ObjectMeta.Annotations[agonesv1.PodSafeToEvictAnnotation]; safeAnnotation == agonesv1.False {
+		delete(pod.ObjectMeta.Annotations, agonesv1.PodSafeToEvictAnnotation)
+	}
+	if _, exists := pod.ObjectMeta.Labels[agonesv1.SafeToEvictLabel]; !exists {
+		switch safe {
+		case agonesv1.EvictionSafeAlways:
+			// For EvictionSafeAlways, we use a label value that does not match the
+			// agones-gameserver-safe-to-evict-false PDB. But we go ahead and label
+			// it, in case someone wants to adopt custom logic for this group of
+			// game servers.
+			pod.ObjectMeta.Labels[agonesv1.SafeToEvictLabel] = agonesv1.True
+		case agonesv1.EvictionSafeNever:
+			pod.ObjectMeta.Labels[agonesv1.SafeToEvictLabel] = agonesv1.False
+		default:
+			return errors.Errorf("eviction.safe == %s, which webhook should have rejected on Autopilot", safe)
+		}
+	}
+	return nil
+}
+
 type autopilotPortAllocator struct {
 	minPort int32
 	maxPort int32
diff --git a/pkg/cloudproduct/gke/gke_test.go b/pkg/cloudproduct/gke/gke_test.go
index 731645cd0a..540e3f946a 100644
--- a/pkg/cloudproduct/gke/gke_test.go
+++ b/pkg/cloudproduct/gke/gke_test.go
@@ -18,6 +18,7 @@ import (
 
 	"agones.dev/agones/pkg/apis"
 	agonesv1 "agones.dev/agones/pkg/apis/agones/v1"
+	"agones.dev/agones/pkg/util/runtime"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	corev1 "k8s.io/api/core/v1"
@@ -76,9 +77,10 @@ func TestSyncPodPortsToGameServer(t *testing.T) {
 
 func TestValidateGameServer(t *testing.T) {
 	for name, tc := range map[string]struct {
-		ports      []agonesv1.GameServerPort
-		scheduling apis.SchedulingStrategy
-		want       []metav1.StatusCause
+		ports       []agonesv1.GameServerPort
+		scheduling  apis.SchedulingStrategy
+		safeToEvict agonesv1.EvictionSafe
+		want        []metav1.StatusCause
 	}{
 		"no ports => validated": {scheduling: apis.Packed},
 		"good ports => validated": {
@@ -102,7 +104,8 @@ func TestValidateGameServer(t *testing.T) {
 					Protocol:      corev1.ProtocolTCP,
 				},
 			},
-			scheduling: apis.Packed,
+			safeToEvict: agonesv1.EvictionSafeAlways,
+			scheduling:  apis.Packed,
 		},
 		"bad policy => fails validation": {
 			ports: []agonesv1.GameServerPort{
@@ -125,23 +128,29 @@ func TestValidateGameServer(t *testing.T) {
 					Protocol:      corev1.ProtocolUDP,
 				},
 			},
-			scheduling: apis.Distributed,
+			safeToEvict: agonesv1.EvictionSafeOnUpgrade,
+			scheduling:  apis.Distributed,
 			want: []metav1.StatusCause{
 				{
 					Type:    "FieldValueInvalid",
-					Message: "PortPolicy must be Dynamic on GKE Autopilot",
+					Message: "portPolicy must be Dynamic on GKE Autopilot",
 					Field:   "bad-udp.portPolicy",
 				},
 				{
 					Type:    "FieldValueInvalid",
-					Message: "PortPolicy must be Dynamic on GKE Autopilot",
+					Message: "portPolicy must be Dynamic on GKE Autopilot",
 					Field:   "another-bad-udp.portPolicy",
 				},
 				{
 					Type:    "FieldValueInvalid",
-					Message: "Scheduling strategy must be Packed on GKE Autopilot",
+					Message: "scheduling strategy must be Packed on GKE Autopilot",
 					Field:   "scheduling",
 				},
+				{
+					Type:    "FieldValueInvalid",
+					Message: "eviction.safe OnUpgrade not supported on GKE Autopilot",
+					Field:   "eviction.safe",
+				},
 			},
 		},
 	} {
@@ -149,6 +158,7 @@ func TestValidateGameServer(t *testing.T) {
 			causes := (&gkeAutopilot{}).ValidateGameServerSpec(&agonesv1.GameServerSpec{
 				Ports:      tc.ports,
 				Scheduling: tc.scheduling,
+				Eviction:   agonesv1.Eviction{Safe: tc.safeToEvict},
 			})
 			require.Equal(t, tc.want, causes)
 		})
@@ -197,6 +207,103 @@ func TestPodSeccompUnconfined(t *testing.T) {
 	}
 }
 
+func TestSetSafeToEvict(t *testing.T) {
+	runtime.FeatureTestMutex.Lock()
+	defer runtime.FeatureTestMutex.Unlock()
+
+	emptyPodAnd := func(f func(*corev1.Pod)) *corev1.Pod {
+		pod := &corev1.Pod{
+			ObjectMeta: metav1.ObjectMeta{
+				Annotations: map[string]string{},
+				Labels:      map[string]string{},
+			},
+		}
+		f(pod)
+		return pod
+	}
+	for desc, tc := range map[string]struct {
+		featureFlags string
+		safeToEvict  agonesv1.EvictionSafe
+		pod          *corev1.Pod
+		wantPod      *corev1.Pod
+		wantErr      bool
+	}{
+		"SafeToEvict feature gate disabled => no change": {
+			featureFlags: "SafeToEvict=false",
+			// intentionally leave pod nil, it'll crash if anything's touched.
+		},
+		"SafeToEvict: Always, no incoming labels/annotations": {
+			featureFlags: "SafeToEvict=true",
+			safeToEvict:  agonesv1.EvictionSafeAlways,
+			pod:          emptyPodAnd(func(*corev1.Pod) {}),
+			wantPod: emptyPodAnd(func(pod *corev1.Pod) {
+				pod.ObjectMeta.Labels[agonesv1.SafeToEvictLabel] = agonesv1.True
+			}),
+		},
+		"SafeToEvict: Never, no incoming labels/annotations": {
+			featureFlags: "SafeToEvict=true",
+			safeToEvict:  agonesv1.EvictionSafeNever,
+			pod:          emptyPodAnd(func(*corev1.Pod) {}),
+			wantPod: emptyPodAnd(func(pod *corev1.Pod) {
+				pod.ObjectMeta.Labels[agonesv1.SafeToEvictLabel] = agonesv1.False
+			}),
+		},
+		"SafeToEvict: OnUpgrade => error": {
+			featureFlags: "SafeToEvict=true",
+			safeToEvict:  agonesv1.EvictionSafeOnUpgrade,
+			pod:          emptyPodAnd(func(*corev1.Pod) {}),
+			wantErr:      true,
+		},
+		"SafeToEvict: Always, incoming labels/annotations": {
+			featureFlags: "SafeToEvict=true",
+			safeToEvict:  agonesv1.EvictionSafeAlways,
+			pod: emptyPodAnd(func(pod *corev1.Pod) {
+				pod.ObjectMeta.Annotations[agonesv1.PodSafeToEvictAnnotation] = "just don't touch, ok?"
+				pod.ObjectMeta.Labels[agonesv1.SafeToEvictLabel] = "seriously, leave it"
+			}),
+			wantPod: emptyPodAnd(func(pod *corev1.Pod) {
+				pod.ObjectMeta.Annotations[agonesv1.PodSafeToEvictAnnotation] = "just don't touch, ok?"
+				pod.ObjectMeta.Labels[agonesv1.SafeToEvictLabel] = "seriously, leave it"
+			}),
+		},
+		"SafeToEvict: Never, incoming labels/annotations": {
+			featureFlags: "SafeToEvict=true",
+			safeToEvict:  agonesv1.EvictionSafeNever,
+			pod: emptyPodAnd(func(pod *corev1.Pod) {
+				pod.ObjectMeta.Annotations[agonesv1.PodSafeToEvictAnnotation] = "a passthrough"
+				pod.ObjectMeta.Labels[agonesv1.SafeToEvictLabel] = "or is it passthru?"
+			}),
+			wantPod: emptyPodAnd(func(pod *corev1.Pod) {
+				pod.ObjectMeta.Annotations[agonesv1.PodSafeToEvictAnnotation] = "a passthrough"
+				pod.ObjectMeta.Labels[agonesv1.SafeToEvictLabel] = "or is it passthru?"
+			}),
+		},
+		"SafeToEvict: Never, but safe-to-evict pod annotation set to false": {
+			featureFlags: "SafeToEvict=true",
+			safeToEvict:  agonesv1.EvictionSafeNever,
+			pod: emptyPodAnd(func(pod *corev1.Pod) {
+				pod.ObjectMeta.Annotations[agonesv1.PodSafeToEvictAnnotation] = agonesv1.False
+			}),
+			wantPod: emptyPodAnd(func(pod *corev1.Pod) {
+				pod.ObjectMeta.Labels[agonesv1.SafeToEvictLabel] = agonesv1.False
+			}),
+		},
+	} {
+		t.Run(desc, func(t *testing.T) {
+			err := runtime.ParseFeatures(tc.featureFlags)
+			assert.NoError(t, err)
+
+			err = (&gkeAutopilot{}).SetEviction(tc.safeToEvict, tc.pod)
+			if tc.wantErr {
+				assert.Error(t, err)
+				return
+			}
+			assert.NoError(t, err)
+			assert.Equal(t, tc.wantPod, tc.pod)
+		})
+	}
+}
+
 func TestAutopilotPortAllocator(t *testing.T) {
 	for name, tc := range map[string]struct {
 		ports          []agonesv1.GameServerPort
diff --git a/site/content/en/docs/Reference/agones_crd_api_reference.html b/site/content/en/docs/Reference/agones_crd_api_reference.html
index 5b877adcee..014603abbe 100644
--- a/site/content/en/docs/Reference/agones_crd_api_reference.html
+++ b/site/content/en/docs/Reference/agones_crd_api_reference.html
@@ -3029,6 +3029,9 @@ <h3 id="agones.dev/v1.SdkServerLogLevel">SdkServerLogLevel
 <p>Packages:</p>
 <ul>
 <li>
+<a href="#multicluster.agones.dev%2fv1">multicluster.agones.dev/v1</a>
+</li>
+<li>
 <a href="#agones.dev%2fv1">agones.dev/v1</a>
 </li>
 <li>
@@ -3037,26 +3040,19 @@ <h3 id="agones.dev/v1.SdkServerLogLevel">SdkServerLogLevel
 <li>
 <a href="#autoscaling.agones.dev%2fv1">autoscaling.agones.dev/v1</a>
 </li>
-<li>
-<a href="#multicluster.agones.dev%2fv1">multicluster.agones.dev/v1</a>
-</li>
 </ul>
-<h2 id="agones.dev/v1">agones.dev/v1</h2>
+<h2 id="multicluster.agones.dev/v1">multicluster.agones.dev/v1</h2>
 <p>
 <p>Package v1 is the v1 version of the API.</p>
 </p>
 Resource Types:
 <ul><li>
-<a href="#agones.dev/v1.Fleet">Fleet</a>
-</li><li>
-<a href="#agones.dev/v1.GameServer">GameServer</a>
-</li><li>
-<a href="#agones.dev/v1.GameServerSet">GameServerSet</a>
+<a href="#multicluster.agones.dev/v1.GameServerAllocationPolicy">GameServerAllocationPolicy</a>
 </li></ul>
-<h3 id="agones.dev/v1.Fleet">Fleet
+<h3 id="multicluster.agones.dev/v1.GameServerAllocationPolicy">GameServerAllocationPolicy
 </h3>
 <p>
-<p>Fleet is the data structure for a Fleet resource</p>
+<p>GameServerAllocationPolicy is the Schema for the gameserverallocationpolicies API</p>
 </p>
 <table>
 <thead>
@@ -3072,7 +3068,7 @@ <h3 id="agones.dev/v1.Fleet">Fleet
 string</td>
 <td>
 <code>
-agones.dev/v1
+multicluster.agones.dev/v1
 </code>
 </td>
 </tr>
@@ -3081,7 +3077,7 @@ <h3 id="agones.dev/v1.Fleet">Fleet
 <code>kind</code></br>
 string
 </td>
-<td><code>Fleet</code></td>
+<td><code>GameServerAllocationPolicy</code></td>
 </tr>
 <tr>
 <td>
@@ -3101,8 +3097,8 @@ <h3 id="agones.dev/v1.Fleet">Fleet
 <td>
 <code>spec</code></br>
 <em>
-<a href="#agones.dev/v1.FleetSpec">
-FleetSpec
+<a href="#multicluster.agones.dev/v1.GameServerAllocationPolicySpec">
+GameServerAllocationPolicySpec
 </a>
 </em>
 </td>
@@ -3112,77 +3108,49 @@ <h3 id="agones.dev/v1.Fleet">Fleet
 <table>
 <tr>
 <td>
-<code>replicas</code></br>
+<code>priority</code></br>
 <em>
 int32
 </em>
 </td>
 <td>
-<p>Replicas are the number of GameServers that should be in this set. Defaults to 0.</p>
-</td>
-</tr>
-<tr>
-<td>
-<code>strategy</code></br>
-<em>
-<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#deploymentstrategy-v1-apps">
-Kubernetes apps/v1.DeploymentStrategy
-</a>
-</em>
-</td>
-<td>
-<p>Deployment strategy</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>scheduling</code></br>
+<code>weight</code></br>
 <em>
-agones.dev/agones/pkg/apis.SchedulingStrategy
+int
 </em>
 </td>
 <td>
-<p>Scheduling strategy. Defaults to &ldquo;Packed&rdquo;.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>template</code></br>
+<code>connectionInfo</code></br>
 <em>
-<a href="#agones.dev/v1.GameServerTemplateSpec">
-GameServerTemplateSpec
+<a href="#multicluster.agones.dev/v1.ClusterConnectionInfo">
+ClusterConnectionInfo
 </a>
 </em>
 </td>
 <td>
-<p>Template the GameServer template to apply for this Fleet</p>
 </td>
 </tr>
 </table>
 </td>
 </tr>
-<tr>
-<td>
-<code>status</code></br>
-<em>
-<a href="#agones.dev/v1.FleetStatus">
-FleetStatus
-</a>
-</em>
-</td>
-<td>
-</td>
-</tr>
 </tbody>
 </table>
-<h3 id="agones.dev/v1.GameServer">GameServer
+<h3 id="multicluster.agones.dev/v1.ClusterConnectionInfo">ClusterConnectionInfo
 </h3>
 <p>
-<p>GameServer is the data structure for a GameServer resource.
-It is worth noting that while there is a <code>GameServerStatus</code> Status entry for the <code>GameServer</code>, it is not
-defined as a subresource - unlike <code>Fleet</code> and other Agones resources.
-This is so that we can retain the ability to change multiple aspects of a <code>GameServer</code> in a single atomic operation,
-which is particularly useful for operations such as allocation.</p>
+(<em>Appears on:</em>
+<a href="#multicluster.agones.dev/v1.GameServerAllocationPolicySpec">GameServerAllocationPolicySpec</a>)
+</p>
+<p>
+<p>ClusterConnectionInfo defines the connection information for a cluster</p>
 </p>
 <table>
 <thead>
@@ -3194,146 +3162,165 @@ <h3 id="agones.dev/v1.GameServer">GameServer
 <tbody>
 <tr>
 <td>
-<code>apiVersion</code></br>
-string</td>
-<td>
-<code>
-agones.dev/v1
-</code>
+<code>clusterName</code></br>
+<em>
+string
+</em>
 </td>
-</tr>
-<tr>
 <td>
-<code>kind</code></br>
-string
+<p>Optional: the name of the targeted cluster</p>
 </td>
-<td><code>GameServer</code></td>
 </tr>
 <tr>
 <td>
-<code>metadata</code></br>
+<code>allocationEndpoints</code></br>
 <em>
-<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#objectmeta-v1-meta">
-Kubernetes meta/v1.ObjectMeta
-</a>
+[]string
 </em>
 </td>
 <td>
-Refer to the Kubernetes API documentation for the fields of the
-<code>metadata</code> field.
+<p>The endpoints for the allocator service in the targeted cluster.
+If the AllocationEndpoints is not set, the allocation happens on local cluster.
+If there are multiple endpoints any of the endpoints that can handle allocation request should suffice</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>spec</code></br>
+<code>secretName</code></br>
 <em>
-<a href="#agones.dev/v1.GameServerSpec">
-GameServerSpec
-</a>
+string
 </em>
 </td>
 <td>
-<br/>
-<br/>
-<table>
+<p>The name of the secret that contains TLS client certificates to connect the allocator server in the targeted cluster</p>
+</td>
+</tr>
 <tr>
 <td>
-<code>container</code></br>
+<code>namespace</code></br>
 <em>
 string
 </em>
 </td>
 <td>
-<p>Container specifies which Pod container is the game server. Only required if there is more than one
-container defined</p>
+<p>The cluster namespace from which to allocate gameservers</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>ports</code></br>
+<code>serverCa</code></br>
 <em>
-<a href="#agones.dev/v1.GameServerPort">
-[]GameServerPort
-</a>
+[]byte
 </em>
 </td>
 <td>
-<p>Ports are the array of ports that can be exposed via the game server</p>
+<p>The PEM encoded server CA, used by the allocator client to authenticate the remote server.</p>
 </td>
 </tr>
+</tbody>
+</table>
+<h3 id="multicluster.agones.dev/v1.ConnectionInfoIterator">ConnectionInfoIterator
+</h3>
+<p>
+<p>ConnectionInfoIterator an iterator on ClusterConnectionInfo</p>
+</p>
+<table>
+<thead>
+<tr>
+<th>Field</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
 <tr>
 <td>
-<code>health</code></br>
+<code>currPriority</code></br>
 <em>
-<a href="#agones.dev/v1.Health">
-Health
-</a>
+int
 </em>
 </td>
 <td>
-<p>Health configures health checking</p>
+<p>currPriority Current priority index from the orderedPriorities</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>scheduling</code></br>
+<code>orderedPriorities</code></br>
 <em>
-agones.dev/agones/pkg/apis.SchedulingStrategy
+[]int32
 </em>
 </td>
 <td>
-<p>Scheduling strategy. Defaults to &ldquo;Packed&rdquo;</p>
+<p>orderedPriorities list of ordered priorities</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>sdkServer</code></br>
+<code>priorityToCluster</code></br>
 <em>
-<a href="#agones.dev/v1.SdkServer">
-SdkServer
-</a>
+map[int32]map[string][]*agones.dev/agones/pkg/apis/multicluster/v1.GameServerAllocationPolicy
 </em>
 </td>
 <td>
-<p>SdkServer specifies parameters for the Agones SDK Server sidecar container</p>
+<p>priorityToCluster Map of priority to cluster-policies map</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>template</code></br>
+<code>clusterBlackList</code></br>
 <em>
-<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#podtemplatespec-v1-core">
-Kubernetes core/v1.PodTemplateSpec
-</a>
+map[string]bool
 </em>
 </td>
 <td>
-<p>Template describes the Pod that will be created for the GameServer</p>
+<p>clusterBlackList the cluster blacklist for the clusters that has already returned</p>
 </td>
 </tr>
+</tbody>
+</table>
+<h3 id="multicluster.agones.dev/v1.GameServerAllocationPolicySpec">GameServerAllocationPolicySpec
+</h3>
+<p>
+(<em>Appears on:</em>
+<a href="#multicluster.agones.dev/v1.GameServerAllocationPolicy">GameServerAllocationPolicy</a>)
+</p>
+<p>
+<p>GameServerAllocationPolicySpec defines the desired state of GameServerAllocationPolicy</p>
+</p>
+<table>
+<thead>
+<tr>
+<th>Field</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
 <tr>
 <td>
-<code>players</code></br>
+<code>priority</code></br>
 <em>
-<a href="#agones.dev/v1.PlayersSpec">
-PlayersSpec
-</a>
+int32
 </em>
 </td>
 <td>
-<em>(Optional)</em>
-<p>(Alpha, PlayerTracking feature flag) Players provides the configuration for player tracking features.</p>
 </td>
 </tr>
-</table>
+<tr>
+<td>
+<code>weight</code></br>
+<em>
+int
+</em>
+</td>
+<td>
 </td>
 </tr>
 <tr>
 <td>
-<code>status</code></br>
+<code>connectionInfo</code></br>
 <em>
-<a href="#agones.dev/v1.GameServerStatus">
-GameServerStatus
+<a href="#multicluster.agones.dev/v1.ClusterConnectionInfo">
+ClusterConnectionInfo
 </a>
 </em>
 </td>
@@ -3342,12 +3329,23 @@ <h3 id="agones.dev/v1.GameServer">GameServer
 </tr>
 </tbody>
 </table>
-<h3 id="agones.dev/v1.GameServerSet">GameServerSet
+<hr/>
+<h2 id="agones.dev/v1">agones.dev/v1</h2>
+<p>
+<p>Package v1 is the v1 version of the API.</p>
+</p>
+Resource Types:
+<ul><li>
+<a href="#agones.dev/v1.Fleet">Fleet</a>
+</li><li>
+<a href="#agones.dev/v1.GameServer">GameServer</a>
+</li><li>
+<a href="#agones.dev/v1.GameServerSet">GameServerSet</a>
+</li></ul>
+<h3 id="agones.dev/v1.Fleet">Fleet
 </h3>
 <p>
-<p>GameServerSet is the data structure for a set of GameServers.
-This matches philosophically with the relationship between
-Deployments and ReplicaSets</p>
+<p>Fleet is the data structure for a Fleet resource</p>
 </p>
 <table>
 <thead>
@@ -3372,7 +3370,7 @@ <h3 id="agones.dev/v1.GameServerSet">GameServerSet
 <code>kind</code></br>
 string
 </td>
-<td><code>GameServerSet</code></td>
+<td><code>Fleet</code></td>
 </tr>
 <tr>
 <td>
@@ -3392,8 +3390,8 @@ <h3 id="agones.dev/v1.GameServerSet">GameServerSet
 <td>
 <code>spec</code></br>
 <em>
-<a href="#agones.dev/v1.GameServerSetSpec">
-GameServerSetSpec
+<a href="#agones.dev/v1.FleetSpec">
+FleetSpec
 </a>
 </em>
 </td>
@@ -3409,31 +3407,44 @@ <h3 id="agones.dev/v1.GameServerSet">GameServerSet
 </em>
 </td>
 <td>
-<p>Replicas are the number of GameServers that should be in this set</p>
+<p>Replicas are the number of GameServers that should be in this set. Defaults to 0.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>scheduling</code></br>
+<code>strategy</code></br>
 <em>
-agones.dev/agones/pkg/apis.SchedulingStrategy
+<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#deploymentstrategy-v1-apps">
+Kubernetes apps/v1.DeploymentStrategy
+</a>
 </em>
 </td>
 <td>
-<p>Scheduling strategy. Defaults to &ldquo;Packed&rdquo;.</p>
+<p>Deployment strategy</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>template</code></br>
+<code>scheduling</code></br>
 <em>
-<a href="#agones.dev/v1.GameServerTemplateSpec">
-GameServerTemplateSpec
+agones.dev/agones/pkg/apis.SchedulingStrategy
+</em>
+</td>
+<td>
+<p>Scheduling strategy. Defaults to &ldquo;Packed&rdquo;.</p>
+</td>
+</tr>
+<tr>
+<td>
+<code>template</code></br>
+<em>
+<a href="#agones.dev/v1.GameServerTemplateSpec">
+GameServerTemplateSpec
 </a>
 </em>
 </td>
 <td>
-<p>Template the GameServer template to apply for this GameServerSet</p>
+<p>Template the GameServer template to apply for this Fleet</p>
 </td>
 </tr>
 </table>
@@ -3443,8 +3454,8 @@ <h3 id="agones.dev/v1.GameServerSet">GameServerSet
 <td>
 <code>status</code></br>
 <em>
-<a href="#agones.dev/v1.GameServerSetStatus">
-GameServerSetStatus
+<a href="#agones.dev/v1.FleetStatus">
+FleetStatus
 </a>
 </em>
 </td>
@@ -3453,15 +3464,14 @@ <h3 id="agones.dev/v1.GameServerSet">GameServerSet
 </tr>
 </tbody>
 </table>
-<h3 id="agones.dev/v1.AggregatedPlayerStatus">AggregatedPlayerStatus
+<h3 id="agones.dev/v1.GameServer">GameServer
 </h3>
 <p>
-(<em>Appears on:</em>
-<a href="#agones.dev/v1.FleetStatus">FleetStatus</a>, 
-<a href="#agones.dev/v1.GameServerSetStatus">GameServerSetStatus</a>)
-</p>
-<p>
-<p>AggregatedPlayerStatus stores total player tracking values</p>
+<p>GameServer is the data structure for a GameServer resource.
+It is worth noting that while there is a <code>GameServerStatus</code> Status entry for the <code>GameServer</code>, it is not
+defined as a subresource - unlike <code>Fleet</code> and other Agones resources.
+This is so that we can retain the ability to change multiple aspects of a <code>GameServer</code> in a single atomic operation,
+which is particularly useful for operations such as allocation.</p>
 </p>
 <table>
 <thead>
@@ -3473,183 +3483,174 @@ <h3 id="agones.dev/v1.AggregatedPlayerStatus">AggregatedPlayerStatus
 <tbody>
 <tr>
 <td>
-<code>count</code></br>
-<em>
-int64
-</em>
+<code>apiVersion</code></br>
+string</td>
+<td>
+<code>
+agones.dev/v1
+</code>
 </td>
+</tr>
+<tr>
 <td>
+<code>kind</code></br>
+string
 </td>
+<td><code>GameServer</code></td>
 </tr>
 <tr>
 <td>
-<code>capacity</code></br>
+<code>metadata</code></br>
 <em>
-int64
+<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#objectmeta-v1-meta">
+Kubernetes meta/v1.ObjectMeta
+</a>
 </em>
 </td>
 <td>
+Refer to the Kubernetes API documentation for the fields of the
+<code>metadata</code> field.
 </td>
 </tr>
-</tbody>
-</table>
-<h3 id="agones.dev/v1.FleetSpec">FleetSpec
-</h3>
-<p>
-(<em>Appears on:</em>
-<a href="#agones.dev/v1.Fleet">Fleet</a>)
-</p>
-<p>
-<p>FleetSpec is the spec for a Fleet</p>
-</p>
-<table>
-<thead>
 <tr>
-<th>Field</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
+<td>
+<code>spec</code></br>
+<em>
+<a href="#agones.dev/v1.GameServerSpec">
+GameServerSpec
+</a>
+</em>
+</td>
+<td>
+<br/>
+<br/>
+<table>
 <tr>
 <td>
-<code>replicas</code></br>
+<code>container</code></br>
 <em>
-int32
+string
 </em>
 </td>
 <td>
-<p>Replicas are the number of GameServers that should be in this set. Defaults to 0.</p>
+<p>Container specifies which Pod container is the game server. Only required if there is more than one
+container defined</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>strategy</code></br>
+<code>ports</code></br>
 <em>
-<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#deploymentstrategy-v1-apps">
-Kubernetes apps/v1.DeploymentStrategy
+<a href="#agones.dev/v1.GameServerPort">
+[]GameServerPort
 </a>
 </em>
 </td>
 <td>
-<p>Deployment strategy</p>
+<p>Ports are the array of ports that can be exposed via the game server</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>scheduling</code></br>
+<code>health</code></br>
 <em>
-agones.dev/agones/pkg/apis.SchedulingStrategy
+<a href="#agones.dev/v1.Health">
+Health
+</a>
 </em>
 </td>
 <td>
-<p>Scheduling strategy. Defaults to &ldquo;Packed&rdquo;.</p>
+<p>Health configures health checking</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>template</code></br>
+<code>scheduling</code></br>
 <em>
-<a href="#agones.dev/v1.GameServerTemplateSpec">
-GameServerTemplateSpec
-</a>
+agones.dev/agones/pkg/apis.SchedulingStrategy
 </em>
 </td>
 <td>
-<p>Template the GameServer template to apply for this Fleet</p>
+<p>Scheduling strategy. Defaults to &ldquo;Packed&rdquo;</p>
 </td>
 </tr>
-</tbody>
-</table>
-<h3 id="agones.dev/v1.FleetStatus">FleetStatus
-</h3>
-<p>
-(<em>Appears on:</em>
-<a href="#agones.dev/v1.Fleet">Fleet</a>, 
-<a href="#autoscaling.agones.dev/v1.FleetAutoscaleRequest">FleetAutoscaleRequest</a>)
-</p>
-<p>
-<p>FleetStatus is the status of a Fleet</p>
-</p>
-<table>
-<thead>
-<tr>
-<th>Field</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
 <tr>
 <td>
-<code>replicas</code></br>
+<code>sdkServer</code></br>
 <em>
-int32
+<a href="#agones.dev/v1.SdkServer">
+SdkServer
+</a>
 </em>
 </td>
 <td>
-<p>Replicas the total number of current GameServer replicas</p>
+<p>SdkServer specifies parameters for the Agones SDK Server sidecar container</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>readyReplicas</code></br>
+<code>template</code></br>
 <em>
-int32
+<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#podtemplatespec-v1-core">
+Kubernetes core/v1.PodTemplateSpec
+</a>
 </em>
 </td>
 <td>
-<p>ReadyReplicas are the number of Ready GameServer replicas</p>
+<p>Template describes the Pod that will be created for the GameServer</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>reservedReplicas</code></br>
+<code>players</code></br>
 <em>
-int32
+<a href="#agones.dev/v1.PlayersSpec">
+PlayersSpec
+</a>
 </em>
 </td>
 <td>
-<p>ReservedReplicas are the total number of Reserved GameServer replicas in this fleet.
-Reserved instances won&rsquo;t be deleted on scale down, but won&rsquo;t cause an autoscaler to scale up.</p>
+<em>(Optional)</em>
+<p>(Alpha, PlayerTracking feature flag) Players provides the configuration for player tracking features.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>allocatedReplicas</code></br>
+<code>eviction</code></br>
 <em>
-int32
+<a href="#agones.dev/v1.Eviction">
+Eviction
+</a>
 </em>
 </td>
 <td>
-<p>AllocatedReplicas are the number of Allocated GameServer replicas</p>
+<em>(Optional)</em>
+<p>(Alpha, SafeToEvict feature flag) Eviction specifies the eviction tolerance of the GameServer. Defaults to &ldquo;Never&rdquo;.</p>
+</td>
+</tr>
+</table>
 </td>
 </tr>
 <tr>
 <td>
-<code>players</code></br>
+<code>status</code></br>
 <em>
-<a href="#agones.dev/v1.AggregatedPlayerStatus">
-AggregatedPlayerStatus
+<a href="#agones.dev/v1.GameServerStatus">
+GameServerStatus
 </a>
 </em>
 </td>
 <td>
-<em>(Optional)</em>
-<p>[Stage:Alpha]
-[FeatureFlag:PlayerTracking]
-Players are the current total player capacity and count for this Fleet</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="agones.dev/v1.GameServerPort">GameServerPort
+<h3 id="agones.dev/v1.GameServerSet">GameServerSet
 </h3>
 <p>
-(<em>Appears on:</em>
-<a href="#agones.dev/v1.GameServerSpec">GameServerSpec</a>)
-</p>
-<p>
-<p>GameServerPort defines a set of Ports that
-are to be exposed via the GameServer</p>
+<p>GameServerSet is the data structure for a set of GameServers.
+This matches philosophically with the relationship between
+Deployments and ReplicaSets</p>
 </p>
 <table>
 <thead>
@@ -3661,89 +3662,194 @@ <h3 id="agones.dev/v1.GameServerPort">GameServerPort
 <tbody>
 <tr>
 <td>
-<code>name</code></br>
-<em>
-string
-</em>
+<code>apiVersion</code></br>
+string</td>
+<td>
+<code>
+agones.dev/v1
+</code>
 </td>
+</tr>
+<tr>
 <td>
-<p>Name is the descriptive name of the port</p>
+<code>kind</code></br>
+string
 </td>
+<td><code>GameServerSet</code></td>
 </tr>
 <tr>
 <td>
-<code>portPolicy</code></br>
+<code>metadata</code></br>
 <em>
-<a href="#agones.dev/v1.PortPolicy">
-PortPolicy
+<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#objectmeta-v1-meta">
+Kubernetes meta/v1.ObjectMeta
 </a>
 </em>
 </td>
 <td>
-<p>PortPolicy defines the policy for how the HostPort is populated.
-Dynamic port will allocate a HostPort within the selected MIN_PORT and MAX_PORT range passed to the controller
-at installation time.
-When <code>Static</code> portPolicy is specified, <code>HostPort</code> is required, to specify the port that game clients will
-connect to</p>
+Refer to the Kubernetes API documentation for the fields of the
+<code>metadata</code> field.
 </td>
 </tr>
 <tr>
 <td>
-<code>container</code></br>
+<code>spec</code></br>
 <em>
-string
+<a href="#agones.dev/v1.GameServerSetSpec">
+GameServerSetSpec
+</a>
 </em>
 </td>
 <td>
-<em>(Optional)</em>
-<p>Container is the name of the container on which to open the port. Defaults to the game server container.</p>
-</td>
-</tr>
+<br/>
+<br/>
+<table>
 <tr>
 <td>
-<code>containerPort</code></br>
+<code>replicas</code></br>
 <em>
 int32
 </em>
 </td>
 <td>
-<p>ContainerPort is the port that is being opened on the specified container&rsquo;s process</p>
+<p>Replicas are the number of GameServers that should be in this set</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>hostPort</code></br>
+<code>scheduling</code></br>
 <em>
-int32
+agones.dev/agones/pkg/apis.SchedulingStrategy
 </em>
 </td>
 <td>
-<p>HostPort the port exposed on the host for clients to connect to</p>
+<p>Scheduling strategy. Defaults to &ldquo;Packed&rdquo;.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>protocol</code></br>
+<code>template</code></br>
 <em>
-<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#protocol-v1-core">
-Kubernetes core/v1.Protocol
+<a href="#agones.dev/v1.GameServerTemplateSpec">
+GameServerTemplateSpec
 </a>
 </em>
 </td>
 <td>
-<p>Protocol is the network protocol being used. Defaults to UDP. TCP and TCPUDP are other options.</p>
+<p>Template the GameServer template to apply for this GameServerSet</p>
 </td>
 </tr>
-</tbody>
 </table>
-<h3 id="agones.dev/v1.GameServerSetSpec">GameServerSetSpec
-</h3>
-<p>
-(<em>Appears on:</em>
-<a href="#agones.dev/v1.GameServerSet">GameServerSet</a>)
+</td>
+</tr>
+<tr>
+<td>
+<code>status</code></br>
+<em>
+<a href="#agones.dev/v1.GameServerSetStatus">
+GameServerSetStatus
+</a>
+</em>
+</td>
+<td>
+</td>
+</tr>
+</tbody>
+</table>
+<h3 id="agones.dev/v1.AggregatedPlayerStatus">AggregatedPlayerStatus
+</h3>
+<p>
+(<em>Appears on:</em>
+<a href="#agones.dev/v1.FleetStatus">FleetStatus</a>, 
+<a href="#agones.dev/v1.GameServerSetStatus">GameServerSetStatus</a>)
 </p>
 <p>
-<p>GameServerSetSpec the specification for GameServerSet</p>
+<p>AggregatedPlayerStatus stores total player tracking values</p>
+</p>
+<table>
+<thead>
+<tr>
+<th>Field</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td>
+<code>count</code></br>
+<em>
+int64
+</em>
+</td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
+<code>capacity</code></br>
+<em>
+int64
+</em>
+</td>
+<td>
+</td>
+</tr>
+</tbody>
+</table>
+<h3 id="agones.dev/v1.Eviction">Eviction
+</h3>
+<p>
+(<em>Appears on:</em>
+<a href="#agones.dev/v1.GameServerSpec">GameServerSpec</a>, 
+<a href="#agones.dev/v1.GameServerStatus">GameServerStatus</a>)
+</p>
+<p>
+<p>Eviction specifies the eviction tolerance of the GameServer</p>
+</p>
+<table>
+<thead>
+<tr>
+<th>Field</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td>
+<code>safe</code></br>
+<em>
+<a href="#agones.dev/v1.EvictionSafe">
+EvictionSafe
+</a>
+</em>
+</td>
+<td>
+<p>(Alpha, SafeToEvict feature flag)
+Game server supports termination via SIGTERM:
+- Always: Allow eviction for both Cluster Autoscaler and node drain for upgrades
+- OnUpgrade: Allow eviction for upgrades alone
+- Never (default): Pod should run to completion</p>
+</td>
+</tr>
+</tbody>
+</table>
+<h3 id="agones.dev/v1.EvictionSafe">EvictionSafe
+(<code>string</code> alias)</p></h3>
+<p>
+(<em>Appears on:</em>
+<a href="#agones.dev/v1.Eviction">Eviction</a>)
+</p>
+<p>
+<p>EvictionSafe specified whether the game server supports termination via SIGTERM</p>
+</p>
+<h3 id="agones.dev/v1.FleetSpec">FleetSpec
+</h3>
+<p>
+(<em>Appears on:</em>
+<a href="#agones.dev/v1.Fleet">Fleet</a>)
+</p>
+<p>
+<p>FleetSpec is the spec for a Fleet</p>
 </p>
 <table>
 <thead>
@@ -3761,7 +3867,20 @@ <h3 id="agones.dev/v1.GameServerSetSpec">GameServerSetSpec
 </em>
 </td>
 <td>
-<p>Replicas are the number of GameServers that should be in this set</p>
+<p>Replicas are the number of GameServers that should be in this set. Defaults to 0.</p>
+</td>
+</tr>
+<tr>
+<td>
+<code>strategy</code></br>
+<em>
+<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#deploymentstrategy-v1-apps">
+Kubernetes apps/v1.DeploymentStrategy
+</a>
+</em>
+</td>
+<td>
+<p>Deployment strategy</p>
 </td>
 </tr>
 <tr>
@@ -3785,19 +3904,20 @@ <h3 id="agones.dev/v1.GameServerSetSpec">GameServerSetSpec
 </em>
 </td>
 <td>
-<p>Template the GameServer template to apply for this GameServerSet</p>
+<p>Template the GameServer template to apply for this Fleet</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="agones.dev/v1.GameServerSetStatus">GameServerSetStatus
+<h3 id="agones.dev/v1.FleetStatus">FleetStatus
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#agones.dev/v1.GameServerSet">GameServerSet</a>)
+<a href="#agones.dev/v1.Fleet">Fleet</a>, 
+<a href="#autoscaling.agones.dev/v1.FleetAutoscaleRequest">FleetAutoscaleRequest</a>)
 </p>
 <p>
-<p>GameServerSetStatus is the status of a GameServerSet</p>
+<p>FleetStatus is the status of a Fleet</p>
 </p>
 <table>
 <thead>
@@ -3815,7 +3935,7 @@ <h3 id="agones.dev/v1.GameServerSetStatus">GameServerSetStatus
 </em>
 </td>
 <td>
-<p>Replicas is the total number of current GameServer replicas</p>
+<p>Replicas the total number of current GameServer replicas</p>
 </td>
 </tr>
 <tr>
@@ -3826,7 +3946,7 @@ <h3 id="agones.dev/v1.GameServerSetStatus">GameServerSetStatus
 </em>
 </td>
 <td>
-<p>ReadyReplicas is the number of Ready GameServer replicas</p>
+<p>ReadyReplicas are the number of Ready GameServer replicas</p>
 </td>
 </tr>
 <tr>
@@ -3837,7 +3957,8 @@ <h3 id="agones.dev/v1.GameServerSetStatus">GameServerSetStatus
 </em>
 </td>
 <td>
-<p>ReservedReplicas is the number of Reserved GameServer replicas</p>
+<p>ReservedReplicas are the total number of Reserved GameServer replicas in this fleet.
+Reserved instances won&rsquo;t be deleted on scale down, but won&rsquo;t cause an autoscaler to scale up.</p>
 </td>
 </tr>
 <tr>
@@ -3848,18 +3969,7 @@ <h3 id="agones.dev/v1.GameServerSetStatus">GameServerSetStatus
 </em>
 </td>
 <td>
-<p>AllocatedReplicas is the number of Allocated GameServer replicas</p>
-</td>
-</tr>
-<tr>
-<td>
-<code>shutdownReplicas</code></br>
-<em>
-int32
-</em>
-</td>
-<td>
-<p>ShutdownReplicas is the number of Shutdown GameServers replicas</p>
+<p>AllocatedReplicas are the number of Allocated GameServer replicas</p>
 </td>
 </tr>
 <tr>
@@ -3875,20 +3985,20 @@ <h3 id="agones.dev/v1.GameServerSetStatus">GameServerSetStatus
 <em>(Optional)</em>
 <p>[Stage:Alpha]
 [FeatureFlag:PlayerTracking]
-Players is the current total player capacity and count for this GameServerSet</p>
+Players are the current total player capacity and count for this Fleet</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="agones.dev/v1.GameServerSpec">GameServerSpec
+<h3 id="agones.dev/v1.GameServerPort">GameServerPort
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#agones.dev/v1.GameServer">GameServer</a>, 
-<a href="#agones.dev/v1.GameServerTemplateSpec">GameServerTemplateSpec</a>)
+<a href="#agones.dev/v1.GameServerSpec">GameServerSpec</a>)
 </p>
 <p>
-<p>GameServerSpec is the spec for a GameServer resource</p>
+<p>GameServerPort defines a set of Ports that
+are to be exposed via the GameServer</p>
 </p>
 <table>
 <thead>
@@ -3900,113 +4010,89 @@ <h3 id="agones.dev/v1.GameServerSpec">GameServerSpec
 <tbody>
 <tr>
 <td>
-<code>container</code></br>
+<code>name</code></br>
 <em>
 string
 </em>
 </td>
 <td>
-<p>Container specifies which Pod container is the game server. Only required if there is more than one
-container defined</p>
-</td>
-</tr>
-<tr>
-<td>
-<code>ports</code></br>
-<em>
-<a href="#agones.dev/v1.GameServerPort">
-[]GameServerPort
-</a>
-</em>
-</td>
-<td>
-<p>Ports are the array of ports that can be exposed via the game server</p>
+<p>Name is the descriptive name of the port</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>health</code></br>
+<code>portPolicy</code></br>
 <em>
-<a href="#agones.dev/v1.Health">
-Health
+<a href="#agones.dev/v1.PortPolicy">
+PortPolicy
 </a>
 </em>
 </td>
 <td>
-<p>Health configures health checking</p>
+<p>PortPolicy defines the policy for how the HostPort is populated.
+Dynamic port will allocate a HostPort within the selected MIN_PORT and MAX_PORT range passed to the controller
+at installation time.
+When <code>Static</code> portPolicy is specified, <code>HostPort</code> is required, to specify the port that game clients will
+connect to</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>scheduling</code></br>
+<code>container</code></br>
 <em>
-agones.dev/agones/pkg/apis.SchedulingStrategy
+string
 </em>
 </td>
 <td>
-<p>Scheduling strategy. Defaults to &ldquo;Packed&rdquo;</p>
+<em>(Optional)</em>
+<p>Container is the name of the container on which to open the port. Defaults to the game server container.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>sdkServer</code></br>
+<code>containerPort</code></br>
 <em>
-<a href="#agones.dev/v1.SdkServer">
-SdkServer
-</a>
+int32
 </em>
 </td>
 <td>
-<p>SdkServer specifies parameters for the Agones SDK Server sidecar container</p>
+<p>ContainerPort is the port that is being opened on the specified container&rsquo;s process</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>template</code></br>
+<code>hostPort</code></br>
 <em>
-<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#podtemplatespec-v1-core">
-Kubernetes core/v1.PodTemplateSpec
-</a>
+int32
 </em>
 </td>
 <td>
-<p>Template describes the Pod that will be created for the GameServer</p>
+<p>HostPort the port exposed on the host for clients to connect to</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>players</code></br>
+<code>protocol</code></br>
 <em>
-<a href="#agones.dev/v1.PlayersSpec">
-PlayersSpec
+<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#protocol-v1-core">
+Kubernetes core/v1.Protocol
 </a>
 </em>
 </td>
 <td>
-<em>(Optional)</em>
-<p>(Alpha, PlayerTracking feature flag) Players provides the configuration for player tracking features.</p>
+<p>Protocol is the network protocol being used. Defaults to UDP. TCP and TCPUDP are other options.</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="agones.dev/v1.GameServerState">GameServerState
-(<code>string</code> alias)</p></h3>
-<p>
-(<em>Appears on:</em>
-<a href="#allocation.agones.dev/v1.GameServerSelector">GameServerSelector</a>, 
-<a href="#agones.dev/v1.GameServerStatus">GameServerStatus</a>)
-</p>
-<p>
-<p>GameServerState is the state for the GameServer</p>
-</p>
-<h3 id="agones.dev/v1.GameServerStatus">GameServerStatus
+<h3 id="agones.dev/v1.GameServerSetSpec">GameServerSetSpec
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#agones.dev/v1.GameServer">GameServer</a>)
+<a href="#agones.dev/v1.GameServerSet">GameServerSet</a>)
 </p>
 <p>
-<p>GameServerStatus is the status for a GameServer resource</p>
+<p>GameServerSetSpec the specification for GameServerSet</p>
 </p>
 <table>
 <thead>
@@ -4018,128 +4104,140 @@ <h3 id="agones.dev/v1.GameServerStatus">GameServerStatus
 <tbody>
 <tr>
 <td>
-<code>state</code></br>
+<code>replicas</code></br>
 <em>
-<a href="#agones.dev/v1.GameServerState">
-GameServerState
-</a>
+int32
 </em>
 </td>
 <td>
-<p>GameServerState is the current state of a GameServer, e.g. Creating, Starting, Ready, etc</p>
+<p>Replicas are the number of GameServers that should be in this set</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>ports</code></br>
+<code>scheduling</code></br>
 <em>
-<a href="#agones.dev/v1.GameServerStatusPort">
-[]GameServerStatusPort
-</a>
+agones.dev/agones/pkg/apis.SchedulingStrategy
 </em>
 </td>
 <td>
+<p>Scheduling strategy. Defaults to &ldquo;Packed&rdquo;.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>address</code></br>
+<code>template</code></br>
 <em>
-string
+<a href="#agones.dev/v1.GameServerTemplateSpec">
+GameServerTemplateSpec
+</a>
 </em>
 </td>
 <td>
+<p>Template the GameServer template to apply for this GameServerSet</p>
 </td>
 </tr>
-<tr>
-<td>
-<code>nodeName</code></br>
-<em>
-string
-</em>
+</tbody>
+</table>
+<h3 id="agones.dev/v1.GameServerSetStatus">GameServerSetStatus
+</h3>
+<p>
+(<em>Appears on:</em>
+<a href="#agones.dev/v1.GameServerSet">GameServerSet</a>)
+</p>
+<p>
+<p>GameServerSetStatus is the status of a GameServerSet</p>
+</p>
+<table>
+<thead>
+<tr>
+<th>Field</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td>
+<code>replicas</code></br>
+<em>
+int32
+</em>
 </td>
 <td>
+<p>Replicas is the total number of current GameServer replicas</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>reservedUntil</code></br>
+<code>readyReplicas</code></br>
 <em>
-<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#time-v1-meta">
-Kubernetes meta/v1.Time
-</a>
+int32
 </em>
 </td>
 <td>
+<p>ReadyReplicas is the number of Ready GameServer replicas</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>players</code></br>
+<code>reservedReplicas</code></br>
 <em>
-<a href="#agones.dev/v1.PlayerStatus">
-PlayerStatus
-</a>
+int32
 </em>
 </td>
 <td>
-<em>(Optional)</em>
-<p>[Stage:Alpha]
-[FeatureFlag:PlayerTracking]</p>
+<p>ReservedReplicas is the number of Reserved GameServer replicas</p>
 </td>
 </tr>
-</tbody>
-</table>
-<h3 id="agones.dev/v1.GameServerStatusPort">GameServerStatusPort
-</h3>
-<p>
-(<em>Appears on:</em>
-<a href="#allocation.agones.dev/v1.GameServerAllocationStatus">GameServerAllocationStatus</a>, 
-<a href="#agones.dev/v1.GameServerStatus">GameServerStatus</a>)
-</p>
-<p>
-<p>GameServerStatusPort shows the port that was allocated to a
-GameServer.</p>
-</p>
-<table>
-<thead>
 <tr>
-<th>Field</th>
-<th>Description</th>
+<td>
+<code>allocatedReplicas</code></br>
+<em>
+int32
+</em>
+</td>
+<td>
+<p>AllocatedReplicas is the number of Allocated GameServer replicas</p>
+</td>
 </tr>
-</thead>
-<tbody>
 <tr>
 <td>
-<code>name</code></br>
+<code>shutdownReplicas</code></br>
 <em>
-string
+int32
 </em>
 </td>
 <td>
+<p>ShutdownReplicas is the number of Shutdown GameServers replicas</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>port</code></br>
+<code>players</code></br>
 <em>
-int32
+<a href="#agones.dev/v1.AggregatedPlayerStatus">
+AggregatedPlayerStatus
+</a>
 </em>
 </td>
 <td>
+<em>(Optional)</em>
+<p>[Stage:Alpha]
+[FeatureFlag:PlayerTracking]
+Players is the current total player capacity and count for this GameServerSet</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="agones.dev/v1.GameServerTemplateSpec">GameServerTemplateSpec
+<h3 id="agones.dev/v1.GameServerSpec">GameServerSpec
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#agones.dev/v1.FleetSpec">FleetSpec</a>, 
-<a href="#agones.dev/v1.GameServerSetSpec">GameServerSetSpec</a>)
+<a href="#agones.dev/v1.GameServer">GameServer</a>, 
+<a href="#agones.dev/v1.GameServerTemplateSpec">GameServerTemplateSpec</a>)
 </p>
 <p>
-<p>GameServerTemplateSpec is a template for GameServers</p>
+<p>GameServerSpec is the spec for a GameServer resource</p>
 </p>
 <table>
 <thead>
@@ -4151,33 +4249,6 @@ <h3 id="agones.dev/v1.GameServerTemplateSpec">GameServerTemplateSpec
 <tbody>
 <tr>
 <td>
-<code>metadata</code></br>
-<em>
-<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#objectmeta-v1-meta">
-Kubernetes meta/v1.ObjectMeta
-</a>
-</em>
-</td>
-<td>
-Refer to the Kubernetes API documentation for the fields of the
-<code>metadata</code> field.
-</td>
-</tr>
-<tr>
-<td>
-<code>spec</code></br>
-<em>
-<a href="#agones.dev/v1.GameServerSpec">
-GameServerSpec
-</a>
-</em>
-</td>
-<td>
-<br/>
-<br/>
-<table>
-<tr>
-<td>
 <code>container</code></br>
 <em>
 string
@@ -4265,19 +4336,40 @@ <h3 id="agones.dev/v1.GameServerTemplateSpec">GameServerTemplateSpec
 <p>(Alpha, PlayerTracking feature flag) Players provides the configuration for player tracking features.</p>
 </td>
 </tr>
-</table>
+<tr>
+<td>
+<code>eviction</code></br>
+<em>
+<a href="#agones.dev/v1.Eviction">
+Eviction
+</a>
+</em>
+</td>
+<td>
+<em>(Optional)</em>
+<p>(Alpha, SafeToEvict feature flag) Eviction specifies the eviction tolerance of the GameServer. Defaults to &ldquo;Never&rdquo;.</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="agones.dev/v1.Health">Health
+<h3 id="agones.dev/v1.GameServerState">GameServerState
+(<code>string</code> alias)</p></h3>
+<p>
+(<em>Appears on:</em>
+<a href="#allocation.agones.dev/v1.GameServerSelector">GameServerSelector</a>, 
+<a href="#agones.dev/v1.GameServerStatus">GameServerStatus</a>)
+</p>
+<p>
+<p>GameServerState is the state for the GameServer</p>
+</p>
+<h3 id="agones.dev/v1.GameServerStatus">GameServerStatus
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#agones.dev/v1.GameServerSpec">GameServerSpec</a>)
+<a href="#agones.dev/v1.GameServer">GameServer</a>)
 </p>
 <p>
-<p>Health configures health checking on the GameServer</p>
+<p>GameServerStatus is the status for a GameServer resource</p>
 </p>
 <table>
 <thead>
@@ -4289,72 +4381,56 @@ <h3 id="agones.dev/v1.Health">Health
 <tbody>
 <tr>
 <td>
-<code>disabled</code></br>
+<code>state</code></br>
 <em>
-bool
+<a href="#agones.dev/v1.GameServerState">
+GameServerState
+</a>
 </em>
 </td>
 <td>
-<p>Disabled is whether health checking is disabled or not</p>
+<p>GameServerState is the current state of a GameServer, e.g. Creating, Starting, Ready, etc</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>periodSeconds</code></br>
+<code>ports</code></br>
 <em>
-int32
+<a href="#agones.dev/v1.GameServerStatusPort">
+[]GameServerStatusPort
+</a>
 </em>
 </td>
 <td>
-<p>PeriodSeconds is the number of seconds each health ping has to occur in</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>failureThreshold</code></br>
+<code>address</code></br>
 <em>
-int32
+string
 </em>
 </td>
 <td>
-<p>FailureThreshold how many failures in a row constitutes unhealthy</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>initialDelaySeconds</code></br>
+<code>nodeName</code></br>
 <em>
-int32
+string
 </em>
 </td>
 <td>
-<p>InitialDelaySeconds initial delay before checking health</p>
 </td>
 </tr>
-</tbody>
-</table>
-<h3 id="agones.dev/v1.PlayerStatus">PlayerStatus
-</h3>
-<p>
-(<em>Appears on:</em>
-<a href="#agones.dev/v1.GameServerStatus">GameServerStatus</a>)
-</p>
-<p>
-<p>PlayerStatus stores the current player capacity values</p>
-</p>
-<table>
-<thead>
-<tr>
-<th>Field</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
 <tr>
 <td>
-<code>count</code></br>
+<code>reservedUntil</code></br>
 <em>
-int64
+<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#time-v1-meta">
+Kubernetes meta/v1.Time
+</a>
 </em>
 </td>
 <td>
@@ -4362,34 +4438,44 @@ <h3 id="agones.dev/v1.PlayerStatus">PlayerStatus
 </tr>
 <tr>
 <td>
-<code>capacity</code></br>
+<code>players</code></br>
 <em>
-int64
+<a href="#agones.dev/v1.PlayerStatus">
+PlayerStatus
+</a>
 </em>
 </td>
 <td>
+<em>(Optional)</em>
+<p>[Stage:Alpha]
+[FeatureFlag:PlayerTracking]</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>ids</code></br>
+<code>eviction</code></br>
 <em>
-[]string
+<a href="#agones.dev/v1.Eviction">
+Eviction
+</a>
 </em>
 </td>
 <td>
+<p>(Alpha, SafeToEvict feature flag) Eviction specifies the eviction tolerance of the GameServer.</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="agones.dev/v1.PlayersSpec">PlayersSpec
+<h3 id="agones.dev/v1.GameServerStatusPort">GameServerStatusPort
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#agones.dev/v1.GameServerSpec">GameServerSpec</a>)
+<a href="#allocation.agones.dev/v1.GameServerAllocationStatus">GameServerAllocationStatus</a>, 
+<a href="#agones.dev/v1.GameServerStatus">GameServerStatus</a>)
 </p>
 <p>
-<p>PlayersSpec tracks the initial player capacity</p>
+<p>GameServerStatusPort shows the port that was allocated to a
+GameServer.</p>
 </p>
 <table>
 <thead>
@@ -4401,9 +4487,19 @@ <h3 id="agones.dev/v1.PlayersSpec">PlayersSpec
 <tbody>
 <tr>
 <td>
-<code>initialCapacity</code></br>
+<code>name</code></br>
 <em>
-int64
+string
+</em>
+</td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
+<code>port</code></br>
+<em>
+int32
 </em>
 </td>
 <td>
@@ -4411,23 +4507,15 @@ <h3 id="agones.dev/v1.PlayersSpec">PlayersSpec
 </tr>
 </tbody>
 </table>
-<h3 id="agones.dev/v1.PortPolicy">PortPolicy
-(<code>string</code> alias)</p></h3>
-<p>
-(<em>Appears on:</em>
-<a href="#agones.dev/v1.GameServerPort">GameServerPort</a>)
-</p>
-<p>
-<p>PortPolicy is the port policy for the GameServer</p>
-</p>
-<h3 id="agones.dev/v1.SdkServer">SdkServer
+<h3 id="agones.dev/v1.GameServerTemplateSpec">GameServerTemplateSpec
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#agones.dev/v1.GameServerSpec">GameServerSpec</a>)
+<a href="#agones.dev/v1.FleetSpec">FleetSpec</a>, 
+<a href="#agones.dev/v1.GameServerSetSpec">GameServerSetSpec</a>)
 </p>
 <p>
-<p>SdkServer specifies parameters for the Agones SDK Server sidecar container</p>
+<p>GameServerTemplateSpec is a template for GameServers</p>
 </p>
 <table>
 <thead>
@@ -4439,230 +4527,147 @@ <h3 id="agones.dev/v1.SdkServer">SdkServer
 <tbody>
 <tr>
 <td>
-<code>logLevel</code></br>
+<code>metadata</code></br>
 <em>
-<a href="#agones.dev/v1.SdkServerLogLevel">
-SdkServerLogLevel
+<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#objectmeta-v1-meta">
+Kubernetes meta/v1.ObjectMeta
 </a>
 </em>
 </td>
 <td>
-<p>LogLevel for SDK server (sidecar) logs. Defaults to &ldquo;Info&rdquo;</p>
+Refer to the Kubernetes API documentation for the fields of the
+<code>metadata</code> field.
 </td>
 </tr>
 <tr>
 <td>
-<code>grpcPort</code></br>
+<code>spec</code></br>
 <em>
-int32
+<a href="#agones.dev/v1.GameServerSpec">
+GameServerSpec
+</a>
 </em>
 </td>
 <td>
-<p>GRPCPort is the port on which the SDK Server binds the gRPC server to accept incoming connections</p>
-</td>
-</tr>
+<br/>
+<br/>
+<table>
 <tr>
 <td>
-<code>httpPort</code></br>
+<code>container</code></br>
 <em>
-int32
+string
 </em>
 </td>
 <td>
-<p>HTTPPort is the port on which the SDK Server binds the HTTP gRPC gateway server to accept incoming connections</p>
-</td>
-</tr>
-</tbody>
-</table>
-<h3 id="agones.dev/v1.SdkServerLogLevel">SdkServerLogLevel
-(<code>string</code> alias)</p></h3>
-<p>
-(<em>Appears on:</em>
-<a href="#agones.dev/v1.SdkServer">SdkServer</a>)
-</p>
-<p>
-<p>SdkServerLogLevel is the log level for SDK server (sidecar) logs</p>
-</p>
-<hr/>
-<h2 id="allocation.agones.dev/v1">allocation.agones.dev/v1</h2>
-<p>
-<p>Package v1 is the v1 version of the API.</p>
-</p>
-Resource Types:
-<ul><li>
-<a href="#allocation.agones.dev/v1.GameServerAllocation">GameServerAllocation</a>
-</li></ul>
-<h3 id="allocation.agones.dev/v1.GameServerAllocation">GameServerAllocation
-</h3>
-<p>
-<p>GameServerAllocation is the data structure for allocating against a set of
-GameServers, defined <code>selectors</code> selectors</p>
-</p>
-<table>
-<thead>
-<tr>
-<th>Field</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td>
-<code>apiVersion</code></br>
-string</td>
-<td>
-<code>
-allocation.agones.dev/v1
-</code>
-</td>
-</tr>
-<tr>
-<td>
-<code>kind</code></br>
-string
+<p>Container specifies which Pod container is the game server. Only required if there is more than one
+container defined</p>
 </td>
-<td><code>GameServerAllocation</code></td>
 </tr>
 <tr>
 <td>
-<code>metadata</code></br>
+<code>ports</code></br>
 <em>
-<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#objectmeta-v1-meta">
-Kubernetes meta/v1.ObjectMeta
+<a href="#agones.dev/v1.GameServerPort">
+[]GameServerPort
 </a>
 </em>
 </td>
 <td>
-Refer to the Kubernetes API documentation for the fields of the
-<code>metadata</code> field.
+<p>Ports are the array of ports that can be exposed via the game server</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>spec</code></br>
-<em>
-<a href="#allocation.agones.dev/v1.GameServerAllocationSpec">
-GameServerAllocationSpec
-</a>
-</em>
-</td>
-<td>
-<br/>
-<br/>
-<table>
-<tr>
-<td>
-<code>multiClusterSetting</code></br>
+<code>health</code></br>
 <em>
-<a href="#allocation.agones.dev/v1.MultiClusterSetting">
-MultiClusterSetting
+<a href="#agones.dev/v1.Health">
+Health
 </a>
 </em>
 </td>
 <td>
-<p>MultiClusterPolicySelector if specified, multi-cluster policies are applied.
-Otherwise, allocation will happen locally.</p>
+<p>Health configures health checking</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>required</code></br>
+<code>scheduling</code></br>
 <em>
-<a href="#allocation.agones.dev/v1.GameServerSelector">
-GameServerSelector
-</a>
+agones.dev/agones/pkg/apis.SchedulingStrategy
 </em>
 </td>
 <td>
-<p>Deprecated: use field Selectors instead. If Selectors is set, this field is ignored.
-Required is the GameServer selector from which to choose GameServers from.
-Defaults to all GameServers.</p>
+<p>Scheduling strategy. Defaults to &ldquo;Packed&rdquo;</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>preferred</code></br>
+<code>sdkServer</code></br>
 <em>
-<a href="#allocation.agones.dev/v1.GameServerSelector">
-[]GameServerSelector
+<a href="#agones.dev/v1.SdkServer">
+SdkServer
 </a>
 </em>
 </td>
 <td>
-<p>Deprecated: use field Selectors instead. If Selectors is set, this field is ignored.
-Preferred is an ordered list of preferred GameServer selectors
-that are optional to be fulfilled, but will be searched before the <code>required</code> selector.
-If the first selector is not matched, the selection attempts the second selector, and so on.
-If any of the preferred selectors are matched, the required selector is not considered.
-This is useful for things like smoke testing of new game servers.</p>
+<p>SdkServer specifies parameters for the Agones SDK Server sidecar container</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>selectors</code></br>
+<code>template</code></br>
 <em>
-<a href="#allocation.agones.dev/v1.GameServerSelector">
-[]GameServerSelector
+<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#podtemplatespec-v1-core">
+Kubernetes core/v1.PodTemplateSpec
 </a>
 </em>
 </td>
 <td>
-<p>Ordered list of GameServer label selectors.
-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.
-Note: This field can only be set if neither Required or Preferred is set.</p>
+<p>Template describes the Pod that will be created for the GameServer</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>scheduling</code></br>
+<code>players</code></br>
 <em>
-agones.dev/agones/pkg/apis.SchedulingStrategy
+<a href="#agones.dev/v1.PlayersSpec">
+PlayersSpec
+</a>
 </em>
 </td>
 <td>
-<p>Scheduling strategy. Defaults to &ldquo;Packed&rdquo;.</p>
+<em>(Optional)</em>
+<p>(Alpha, PlayerTracking feature flag) Players provides the configuration for player tracking features.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>metadata</code></br>
+<code>eviction</code></br>
 <em>
-<a href="#allocation.agones.dev/v1.MetaPatch">
-MetaPatch
+<a href="#agones.dev/v1.Eviction">
+Eviction
 </a>
 </em>
 </td>
 <td>
-<p>MetaPatch is optional custom metadata that is added to the game server at allocation
-You can use this to tell the server necessary session data</p>
+<em>(Optional)</em>
+<p>(Alpha, SafeToEvict feature flag) Eviction specifies the eviction tolerance of the GameServer. Defaults to &ldquo;Never&rdquo;.</p>
 </td>
 </tr>
 </table>
 </td>
 </tr>
-<tr>
-<td>
-<code>status</code></br>
-<em>
-<a href="#allocation.agones.dev/v1.GameServerAllocationStatus">
-GameServerAllocationStatus
-</a>
-</em>
-</td>
-<td>
-</td>
-</tr>
 </tbody>
 </table>
-<h3 id="allocation.agones.dev/v1.GameServerAllocationSpec">GameServerAllocationSpec
+<h3 id="agones.dev/v1.Health">Health
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#allocation.agones.dev/v1.GameServerAllocation">GameServerAllocation</a>)
+<a href="#agones.dev/v1.GameServerSpec">GameServerSpec</a>)
 </p>
 <p>
-<p>GameServerAllocationSpec is the spec for a GameServerAllocation</p>
+<p>Health configures health checking on the GameServer</p>
 </p>
 <table>
 <thead>
@@ -4674,111 +4679,58 @@ <h3 id="allocation.agones.dev/v1.GameServerAllocationSpec">GameServerAllocationS
 <tbody>
 <tr>
 <td>
-<code>multiClusterSetting</code></br>
-<em>
-<a href="#allocation.agones.dev/v1.MultiClusterSetting">
-MultiClusterSetting
-</a>
-</em>
-</td>
-<td>
-<p>MultiClusterPolicySelector if specified, multi-cluster policies are applied.
-Otherwise, allocation will happen locally.</p>
-</td>
-</tr>
-<tr>
-<td>
-<code>required</code></br>
-<em>
-<a href="#allocation.agones.dev/v1.GameServerSelector">
-GameServerSelector
-</a>
-</em>
-</td>
-<td>
-<p>Deprecated: use field Selectors instead. If Selectors is set, this field is ignored.
-Required is the GameServer selector from which to choose GameServers from.
-Defaults to all GameServers.</p>
-</td>
-</tr>
-<tr>
-<td>
-<code>preferred</code></br>
+<code>disabled</code></br>
 <em>
-<a href="#allocation.agones.dev/v1.GameServerSelector">
-[]GameServerSelector
-</a>
+bool
 </em>
 </td>
 <td>
-<p>Deprecated: use field Selectors instead. If Selectors is set, this field is ignored.
-Preferred is an ordered list of preferred GameServer selectors
-that are optional to be fulfilled, but will be searched before the <code>required</code> selector.
-If the first selector is not matched, the selection attempts the second selector, and so on.
-If any of the preferred selectors are matched, the required selector is not considered.
-This is useful for things like smoke testing of new game servers.</p>
+<p>Disabled is whether health checking is disabled or not</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>selectors</code></br>
+<code>periodSeconds</code></br>
 <em>
-<a href="#allocation.agones.dev/v1.GameServerSelector">
-[]GameServerSelector
-</a>
+int32
 </em>
 </td>
 <td>
-<p>Ordered list of GameServer label selectors.
-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.
-Note: This field can only be set if neither Required or Preferred is set.</p>
+<p>PeriodSeconds is the number of seconds each health ping has to occur in</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>scheduling</code></br>
+<code>failureThreshold</code></br>
 <em>
-agones.dev/agones/pkg/apis.SchedulingStrategy
+int32
 </em>
 </td>
 <td>
-<p>Scheduling strategy. Defaults to &ldquo;Packed&rdquo;.</p>
+<p>FailureThreshold how many failures in a row constitutes unhealthy</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>metadata</code></br>
+<code>initialDelaySeconds</code></br>
 <em>
-<a href="#allocation.agones.dev/v1.MetaPatch">
-MetaPatch
-</a>
+int32
 </em>
 </td>
 <td>
-<p>MetaPatch is optional custom metadata that is added to the game server at allocation
-You can use this to tell the server necessary session data</p>
+<p>InitialDelaySeconds initial delay before checking health</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="allocation.agones.dev/v1.GameServerAllocationState">GameServerAllocationState
-(<code>string</code> alias)</p></h3>
-<p>
-(<em>Appears on:</em>
-<a href="#allocation.agones.dev/v1.GameServerAllocationStatus">GameServerAllocationStatus</a>)
-</p>
-<p>
-<p>GameServerAllocationState is the Allocation state</p>
-</p>
-<h3 id="allocation.agones.dev/v1.GameServerAllocationStatus">GameServerAllocationStatus
+<h3 id="agones.dev/v1.PlayerStatus">PlayerStatus
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#allocation.agones.dev/v1.GameServerAllocation">GameServerAllocation</a>)
+<a href="#agones.dev/v1.GameServerStatus">GameServerStatus</a>)
 </p>
 <p>
-<p>GameServerAllocationStatus is the status for an GameServerAllocation resource</p>
+<p>PlayerStatus stores the current player capacity values</p>
 </p>
 <table>
 <thead>
@@ -4790,34 +4742,19 @@ <h3 id="allocation.agones.dev/v1.GameServerAllocationStatus">GameServerAllocatio
 <tbody>
 <tr>
 <td>
-<code>state</code></br>
+<code>count</code></br>
 <em>
-<a href="#allocation.agones.dev/v1.GameServerAllocationState">
-GameServerAllocationState
-</a>
+int64
 </em>
 </td>
 <td>
-<p>GameServerState is the current state of an GameServerAllocation, e.g. Allocated, or UnAllocated</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>gameServerName</code></br>
-<em>
-string
-</em>
-</td>
-<td>
-</td>
-</tr>
-<tr>
-<td>
-<code>ports</code></br>
+<code>capacity</code></br>
 <em>
-<a href="#agones.dev/v1.GameServerStatusPort">
-[]GameServerStatusPort
-</a>
+int64
 </em>
 </td>
 <td>
@@ -4825,47 +4762,62 @@ <h3 id="allocation.agones.dev/v1.GameServerAllocationStatus">GameServerAllocatio
 </tr>
 <tr>
 <td>
-<code>address</code></br>
+<code>ids</code></br>
 <em>
-string
+[]string
 </em>
 </td>
 <td>
 </td>
 </tr>
+</tbody>
+</table>
+<h3 id="agones.dev/v1.PlayersSpec">PlayersSpec
+</h3>
+<p>
+(<em>Appears on:</em>
+<a href="#agones.dev/v1.GameServerSpec">GameServerSpec</a>)
+</p>
+<p>
+<p>PlayersSpec tracks the initial player capacity</p>
+</p>
+<table>
+<thead>
 <tr>
-<td>
-<code>nodeName</code></br>
-<em>
-string
-</em>
-</td>
-<td>
-</td>
+<th>Field</th>
+<th>Description</th>
 </tr>
+</thead>
+<tbody>
 <tr>
 <td>
-<code>source</code></br>
+<code>initialCapacity</code></br>
 <em>
-string
+int64
 </em>
 </td>
 <td>
-<p>If the allocation is from a remote cluster, Source is the endpoint of the remote agones-allocator.
-Otherwise, Source is &ldquo;local&rdquo;</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="allocation.agones.dev/v1.GameServerSelector">GameServerSelector
+<h3 id="agones.dev/v1.PortPolicy">PortPolicy
+(<code>string</code> alias)</p></h3>
+<p>
+(<em>Appears on:</em>
+<a href="#agones.dev/v1.GameServerPort">GameServerPort</a>)
+</p>
+<p>
+<p>PortPolicy is the port policy for the GameServer</p>
+</p>
+<h3 id="agones.dev/v1.SdkServer">SdkServer
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#allocation.agones.dev/v1.GameServerAllocationSpec">GameServerAllocationSpec</a>)
+<a href="#agones.dev/v1.GameServerSpec">GameServerSpec</a>)
 </p>
 <p>
-<p>GameServerSelector contains all the filter options for selecting
-a GameServer for allocation.</p>
+<p>SdkServer specifies parameters for the Agones SDK Server sidecar container</p>
 </p>
 <table>
 <thead>
@@ -4877,65 +4829,64 @@ <h3 id="allocation.agones.dev/v1.GameServerSelector">GameServerSelector
 <tbody>
 <tr>
 <td>
-<code>LabelSelector</code></br>
+<code>logLevel</code></br>
 <em>
-<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#labelselector-v1-meta">
-Kubernetes meta/v1.LabelSelector
+<a href="#agones.dev/v1.SdkServerLogLevel">
+SdkServerLogLevel
 </a>
 </em>
 </td>
 <td>
-<p>
-(Members of <code>LabelSelector</code> are embedded into this type.)
-</p>
-<p>See: <a href="https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/">https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/</a></p>
+<p>LogLevel for SDK server (sidecar) logs. Defaults to &ldquo;Info&rdquo;</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>gameServerState</code></br>
+<code>grpcPort</code></br>
 <em>
-<a href="#agones.dev/v1.GameServerState">
-GameServerState
-</a>
+int32
 </em>
 </td>
 <td>
-<em>(Optional)</em>
-<p>[Stage:Beta]
-[FeatureFlag:StateAllocationFilter]
-GameServerState specifies which State is the filter to be used when attempting to retrieve a GameServer
-via Allocation. Defaults to &ldquo;Ready&rdquo;. The only other option is &ldquo;Allocated&rdquo;, which can be used in conjunction with
-label/annotation/player selectors to retrieve an already Allocated GameServer.</p>
+<p>GRPCPort is the port on which the SDK Server binds the gRPC server to accept incoming connections</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>players</code></br>
+<code>httpPort</code></br>
 <em>
-<a href="#allocation.agones.dev/v1.PlayerSelector">
-PlayerSelector
-</a>
+int32
 </em>
 </td>
 <td>
-<em>(Optional)</em>
-<p>[Stage:Alpha]
-[FeatureFlag:PlayerAllocationFilter]
-Players provides a filter on minimum and maximum values for player capacity when retrieving a GameServer
-through Allocation. Defaults to no limits.</p>
+<p>HTTPPort is the port on which the SDK Server binds the HTTP gRPC gateway server to accept incoming connections</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="allocation.agones.dev/v1.MetaPatch">MetaPatch
-</h3>
+<h3 id="agones.dev/v1.SdkServerLogLevel">SdkServerLogLevel
+(<code>string</code> alias)</p></h3>
 <p>
 (<em>Appears on:</em>
-<a href="#allocation.agones.dev/v1.GameServerAllocationSpec">GameServerAllocationSpec</a>)
+<a href="#agones.dev/v1.SdkServer">SdkServer</a>)
 </p>
 <p>
-<p>MetaPatch is the metadata used to patch the GameServer metadata on allocation</p>
+<p>SdkServerLogLevel is the log level for SDK server (sidecar) logs</p>
+</p>
+<hr/>
+<h2 id="allocation.agones.dev/v1">allocation.agones.dev/v1</h2>
+<p>
+<p>Package v1 is the v1 version of the API.</p>
+</p>
+Resource Types:
+<ul><li>
+<a href="#allocation.agones.dev/v1.GameServerAllocation">GameServerAllocation</a>
+</li></ul>
+<h3 id="allocation.agones.dev/v1.GameServerAllocation">GameServerAllocation
+</h3>
+<p>
+<p>GameServerAllocation is the data structure for allocating against a set of
+GameServers, defined <code>selectors</code> selectors</p>
 </p>
 <table>
 <thead>
@@ -4947,59 +4898,145 @@ <h3 id="allocation.agones.dev/v1.MetaPatch">MetaPatch
 <tbody>
 <tr>
 <td>
-<code>labels</code></br>
+<code>apiVersion</code></br>
+string</td>
+<td>
+<code>
+allocation.agones.dev/v1
+</code>
+</td>
+</tr>
+<tr>
+<td>
+<code>kind</code></br>
+string
+</td>
+<td><code>GameServerAllocation</code></td>
+</tr>
+<tr>
+<td>
+<code>metadata</code></br>
 <em>
-map[string]string
+<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#objectmeta-v1-meta">
+Kubernetes meta/v1.ObjectMeta
+</a>
 </em>
 </td>
 <td>
+Refer to the Kubernetes API documentation for the fields of the
+<code>metadata</code> field.
 </td>
 </tr>
 <tr>
 <td>
-<code>annotations</code></br>
+<code>spec</code></br>
 <em>
-map[string]string
+<a href="#allocation.agones.dev/v1.GameServerAllocationSpec">
+GameServerAllocationSpec
+</a>
 </em>
 </td>
 <td>
+<br/>
+<br/>
+<table>
+<tr>
+<td>
+<code>multiClusterSetting</code></br>
+<em>
+<a href="#allocation.agones.dev/v1.MultiClusterSetting">
+MultiClusterSetting
+</a>
+</em>
+</td>
+<td>
+<p>MultiClusterPolicySelector if specified, multi-cluster policies are applied.
+Otherwise, allocation will happen locally.</p>
 </td>
 </tr>
-</tbody>
-</table>
-<h3 id="allocation.agones.dev/v1.MultiClusterSetting">MultiClusterSetting
-</h3>
-<p>
-(<em>Appears on:</em>
-<a href="#allocation.agones.dev/v1.GameServerAllocationSpec">GameServerAllocationSpec</a>)
-</p>
-<p>
-<p>MultiClusterSetting specifies settings for multi-cluster allocation.</p>
-</p>
-<table>
-<thead>
 <tr>
-<th>Field</th>
-<th>Description</th>
+<td>
+<code>required</code></br>
+<em>
+<a href="#allocation.agones.dev/v1.GameServerSelector">
+GameServerSelector
+</a>
+</em>
+</td>
+<td>
+<p>Deprecated: use field Selectors instead. If Selectors is set, this field is ignored.
+Required is the GameServer selector from which to choose GameServers from.
+Defaults to all GameServers.</p>
+</td>
 </tr>
-</thead>
-<tbody>
 <tr>
 <td>
-<code>enabled</code></br>
+<code>preferred</code></br>
 <em>
-bool
+<a href="#allocation.agones.dev/v1.GameServerSelector">
+[]GameServerSelector
+</a>
 </em>
 </td>
 <td>
+<p>Deprecated: use field Selectors instead. If Selectors is set, this field is ignored.
+Preferred is an ordered list of preferred GameServer selectors
+that are optional to be fulfilled, but will be searched before the <code>required</code> selector.
+If the first selector is not matched, the selection attempts the second selector, and so on.
+If any of the preferred selectors are matched, the required selector is not considered.
+This is useful for things like smoke testing of new game servers.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>policySelector</code></br>
+<code>selectors</code></br>
 <em>
-<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#labelselector-v1-meta">
-Kubernetes meta/v1.LabelSelector
+<a href="#allocation.agones.dev/v1.GameServerSelector">
+[]GameServerSelector
+</a>
+</em>
+</td>
+<td>
+<p>Ordered list of GameServer label selectors.
+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.
+Note: This field can only be set if neither Required or Preferred is set.</p>
+</td>
+</tr>
+<tr>
+<td>
+<code>scheduling</code></br>
+<em>
+agones.dev/agones/pkg/apis.SchedulingStrategy
+</em>
+</td>
+<td>
+<p>Scheduling strategy. Defaults to &ldquo;Packed&rdquo;.</p>
+</td>
+</tr>
+<tr>
+<td>
+<code>metadata</code></br>
+<em>
+<a href="#allocation.agones.dev/v1.MetaPatch">
+MetaPatch
+</a>
+</em>
+</td>
+<td>
+<p>MetaPatch is optional custom metadata that is added to the game server at allocation
+You can use this to tell the server necessary session data</p>
+</td>
+</tr>
+</table>
+</td>
+</tr>
+<tr>
+<td>
+<code>status</code></br>
+<em>
+<a href="#allocation.agones.dev/v1.GameServerAllocationStatus">
+GameServerAllocationStatus
 </a>
 </em>
 </td>
@@ -5008,14 +5045,14 @@ <h3 id="allocation.agones.dev/v1.MultiClusterSetting">MultiClusterSetting
 </tr>
 </tbody>
 </table>
-<h3 id="allocation.agones.dev/v1.PlayerSelector">PlayerSelector
+<h3 id="allocation.agones.dev/v1.GameServerAllocationSpec">GameServerAllocationSpec
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#allocation.agones.dev/v1.GameServerSelector">GameServerSelector</a>)
+<a href="#allocation.agones.dev/v1.GameServerAllocation">GameServerAllocation</a>)
 </p>
 <p>
-<p>PlayerSelector is the filter options for a GameServer based on player counts</p>
+<p>GameServerAllocationSpec is the spec for a GameServerAllocation</p>
 </p>
 <table>
 <thead>
@@ -5027,95 +5064,136 @@ <h3 id="allocation.agones.dev/v1.PlayerSelector">PlayerSelector
 <tbody>
 <tr>
 <td>
-<code>minAvailable</code></br>
+<code>multiClusterSetting</code></br>
 <em>
-int64
+<a href="#allocation.agones.dev/v1.MultiClusterSetting">
+MultiClusterSetting
+</a>
 </em>
 </td>
 <td>
+<p>MultiClusterPolicySelector if specified, multi-cluster policies are applied.
+Otherwise, allocation will happen locally.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>maxAvailable</code></br>
+<code>required</code></br>
 <em>
-int64
+<a href="#allocation.agones.dev/v1.GameServerSelector">
+GameServerSelector
+</a>
 </em>
 </td>
 <td>
+<p>Deprecated: use field Selectors instead. If Selectors is set, this field is ignored.
+Required is the GameServer selector from which to choose GameServers from.
+Defaults to all GameServers.</p>
 </td>
 </tr>
-</tbody>
-</table>
-<hr/>
-<h2 id="autoscaling.agones.dev/v1">autoscaling.agones.dev/v1</h2>
-<p>
-<p>Package v1 is the v1 version of the API.</p>
-</p>
-Resource Types:
-<ul><li>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscaler">FleetAutoscaler</a>
-</li></ul>
-<h3 id="autoscaling.agones.dev/v1.FleetAutoscaler">FleetAutoscaler
-</h3>
-<p>
-<p>FleetAutoscaler is the data structure for a FleetAutoscaler resource</p>
-</p>
-<table>
-<thead>
 <tr>
-<th>Field</th>
-<th>Description</th>
+<td>
+<code>preferred</code></br>
+<em>
+<a href="#allocation.agones.dev/v1.GameServerSelector">
+[]GameServerSelector
+</a>
+</em>
+</td>
+<td>
+<p>Deprecated: use field Selectors instead. If Selectors is set, this field is ignored.
+Preferred is an ordered list of preferred GameServer selectors
+that are optional to be fulfilled, but will be searched before the <code>required</code> selector.
+If the first selector is not matched, the selection attempts the second selector, and so on.
+If any of the preferred selectors are matched, the required selector is not considered.
+This is useful for things like smoke testing of new game servers.</p>
+</td>
 </tr>
-</thead>
-<tbody>
 <tr>
 <td>
-<code>apiVersion</code></br>
-string</td>
+<code>selectors</code></br>
+<em>
+<a href="#allocation.agones.dev/v1.GameServerSelector">
+[]GameServerSelector
+</a>
+</em>
+</td>
 <td>
-<code>
-autoscaling.agones.dev/v1
-</code>
+<p>Ordered list of GameServer label selectors.
+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.
+Note: This field can only be set if neither Required or Preferred is set.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>kind</code></br>
-string
+<code>scheduling</code></br>
+<em>
+agones.dev/agones/pkg/apis.SchedulingStrategy
+</em>
+</td>
+<td>
+<p>Scheduling strategy. Defaults to &ldquo;Packed&rdquo;.</p>
 </td>
-<td><code>FleetAutoscaler</code></td>
 </tr>
 <tr>
 <td>
 <code>metadata</code></br>
 <em>
-<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#objectmeta-v1-meta">
-Kubernetes meta/v1.ObjectMeta
+<a href="#allocation.agones.dev/v1.MetaPatch">
+MetaPatch
 </a>
 </em>
 </td>
 <td>
-Refer to the Kubernetes API documentation for the fields of the
-<code>metadata</code> field.
+<p>MetaPatch is optional custom metadata that is added to the game server at allocation
+You can use this to tell the server necessary session data</p>
 </td>
 </tr>
+</tbody>
+</table>
+<h3 id="allocation.agones.dev/v1.GameServerAllocationState">GameServerAllocationState
+(<code>string</code> alias)</p></h3>
+<p>
+(<em>Appears on:</em>
+<a href="#allocation.agones.dev/v1.GameServerAllocationStatus">GameServerAllocationStatus</a>)
+</p>
+<p>
+<p>GameServerAllocationState is the Allocation state</p>
+</p>
+<h3 id="allocation.agones.dev/v1.GameServerAllocationStatus">GameServerAllocationStatus
+</h3>
+<p>
+(<em>Appears on:</em>
+<a href="#allocation.agones.dev/v1.GameServerAllocation">GameServerAllocation</a>)
+</p>
+<p>
+<p>GameServerAllocationStatus is the status for an GameServerAllocation resource</p>
+</p>
+<table>
+<thead>
+<tr>
+<th>Field</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
 <tr>
 <td>
-<code>spec</code></br>
+<code>state</code></br>
 <em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscalerSpec">
-FleetAutoscalerSpec
+<a href="#allocation.agones.dev/v1.GameServerAllocationState">
+GameServerAllocationState
 </a>
 </em>
 </td>
 <td>
-<br/>
-<br/>
-<table>
+<p>GameServerState is the current state of an GameServerAllocation, e.g. Allocated, or UnAllocated</p>
+</td>
+</tr>
 <tr>
 <td>
-<code>fleetName</code></br>
+<code>gameServerName</code></br>
 <em>
 string
 </em>
@@ -5125,58 +5203,59 @@ <h3 id="autoscaling.agones.dev/v1.FleetAutoscaler">FleetAutoscaler
 </tr>
 <tr>
 <td>
-<code>policy</code></br>
+<code>ports</code></br>
 <em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscalerPolicy">
-FleetAutoscalerPolicy
+<a href="#agones.dev/v1.GameServerStatusPort">
+[]GameServerStatusPort
 </a>
 </em>
 </td>
 <td>
-<p>Autoscaling policy</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>sync</code></br>
+<code>address</code></br>
 <em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscalerSync">
-FleetAutoscalerSync
-</a>
+string
 </em>
 </td>
 <td>
-<em>(Optional)</em>
-<p>[Stage:Beta]
-[FeatureFlag:CustomFasSyncInterval]
-Sync defines when FleetAutoscalers runs autoscaling</p>
 </td>
 </tr>
-</table>
+<tr>
+<td>
+<code>nodeName</code></br>
+<em>
+string
+</em>
+</td>
+<td>
 </td>
 </tr>
 <tr>
 <td>
-<code>status</code></br>
+<code>source</code></br>
 <em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscalerStatus">
-FleetAutoscalerStatus
-</a>
+string
 </em>
 </td>
 <td>
+<p>If the allocation is from a remote cluster, Source is the endpoint of the remote agones-allocator.
+Otherwise, Source is &ldquo;local&rdquo;</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="autoscaling.agones.dev/v1.BufferPolicy">BufferPolicy
+<h3 id="allocation.agones.dev/v1.GameServerSelector">GameServerSelector
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscalerPolicy">FleetAutoscalerPolicy</a>)
+<a href="#allocation.agones.dev/v1.GameServerAllocationSpec">GameServerAllocationSpec</a>)
 </p>
 <p>
-<p>BufferPolicy controls the desired behavior of the buffer policy.</p>
+<p>GameServerSelector contains all the filter options for selecting
+a GameServer for allocation.</p>
 </p>
 <table>
 <thead>
@@ -5188,59 +5267,65 @@ <h3 id="autoscaling.agones.dev/v1.BufferPolicy">BufferPolicy
 <tbody>
 <tr>
 <td>
-<code>maxReplicas</code></br>
+<code>LabelSelector</code></br>
 <em>
-int32
+<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#labelselector-v1-meta">
+Kubernetes meta/v1.LabelSelector
+</a>
 </em>
 </td>
 <td>
-<p>MaxReplicas is the maximum amount of replicas that the fleet may have.
-It must be bigger than both MinReplicas and BufferSize</p>
+<p>
+(Members of <code>LabelSelector</code> are embedded into this type.)
+</p>
+<p>See: <a href="https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/">https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/</a></p>
 </td>
 </tr>
 <tr>
 <td>
-<code>minReplicas</code></br>
+<code>gameServerState</code></br>
 <em>
-int32
+<a href="#agones.dev/v1.GameServerState">
+GameServerState
+</a>
 </em>
 </td>
 <td>
-<p>MinReplicas is the minimum amount of replicas that the fleet must have
-If zero, it is ignored.
-If non zero, it must be smaller than MaxReplicas and bigger than BufferSize</p>
+<em>(Optional)</em>
+<p>[Stage:Beta]
+[FeatureFlag:StateAllocationFilter]
+GameServerState specifies which State is the filter to be used when attempting to retrieve a GameServer
+via Allocation. Defaults to &ldquo;Ready&rdquo;. The only other option is &ldquo;Allocated&rdquo;, which can be used in conjunction with
+label/annotation/player selectors to retrieve an already Allocated GameServer.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>bufferSize</code></br>
+<code>players</code></br>
 <em>
-k8s.io/apimachinery/pkg/util/intstr.IntOrString
+<a href="#allocation.agones.dev/v1.PlayerSelector">
+PlayerSelector
+</a>
 </em>
 </td>
 <td>
-<p>BufferSize defines how many replicas the autoscaler tries to have ready all the time
-Value can be an absolute number (ex: 5) or a percentage of desired gs instances (ex: 15%)
-Absolute number is calculated from percentage by rounding up.
-Example: when this is set to 20%, the autoscaler will make sure that 20%
-of the fleet&rsquo;s game server replicas are ready. When this is set to 20,
-the autoscaler will make sure that there are 20 available game servers
-Must be bigger than 0
-Note: by &ldquo;ready&rdquo; we understand in this case &ldquo;non-allocated&rdquo;; this is done to ensure robustness
-and computation stability in different edge case (fleet just created, not enough
-capacity in the cluster etc)</p>
+<em>(Optional)</em>
+<p>[Stage:Alpha]
+[FeatureFlag:PlayerAllocationFilter]
+Players provides a filter on minimum and maximum values for player capacity when retrieving a GameServer
+through Allocation. Defaults to no limits.</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="autoscaling.agones.dev/v1.FixedIntervalSync">FixedIntervalSync
+<h3 id="allocation.agones.dev/v1.MetaPatch">MetaPatch
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscalerSync">FleetAutoscalerSync</a>)
+<a href="#allocation.agones.dev/v1.GameServerAllocationSpec">GameServerAllocationSpec</a>)
 </p>
 <p>
-<p>FixedIntervalSync controls the desired behavior of the fixed interval based sync.</p>
+<p>MetaPatch is the metadata used to patch the GameServer metadata on allocation</p>
 </p>
 <table>
 <thead>
@@ -5252,25 +5337,34 @@ <h3 id="autoscaling.agones.dev/v1.FixedIntervalSync">FixedIntervalSync
 <tbody>
 <tr>
 <td>
-<code>seconds</code></br>
+<code>labels</code></br>
 <em>
-int32
+map[string]string
+</em>
+</td>
+<td>
+</td>
+</tr>
+<tr>
+<td>
+<code>annotations</code></br>
+<em>
+map[string]string
 </em>
 </td>
 <td>
-<p>Seconds defines how often we run fleet autoscaling in seconds</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="autoscaling.agones.dev/v1.FleetAutoscaleRequest">FleetAutoscaleRequest
+<h3 id="allocation.agones.dev/v1.MultiClusterSetting">MultiClusterSetting
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscaleReview">FleetAutoscaleReview</a>)
+<a href="#allocation.agones.dev/v1.GameServerAllocationSpec">GameServerAllocationSpec</a>)
 </p>
 <p>
-<p>FleetAutoscaleRequest defines the request to webhook autoscaler endpoint</p>
+<p>MultiClusterSetting specifies settings for multi-cluster allocation.</p>
 </p>
 <table>
 <thead>
@@ -5282,63 +5376,36 @@ <h3 id="autoscaling.agones.dev/v1.FleetAutoscaleRequest">FleetAutoscaleRequest
 <tbody>
 <tr>
 <td>
-<code>uid</code></br>
-<em>
-k8s.io/apimachinery/pkg/types.UID
-</em>
-</td>
-<td>
-<p>UID is an identifier for the individual request/response. It allows us to distinguish instances of requests which are
-otherwise identical (parallel requests, requests when earlier requests did not modify etc)
-The UID is meant to track the round trip (request/response) between the Autoscaler and the WebHook, not the user request.
-It is suitable for correlating log entries between the webhook and apiserver, for either auditing or debugging.</p>
-</td>
-</tr>
-<tr>
-<td>
-<code>name</code></br>
-<em>
-string
-</em>
-</td>
-<td>
-<p>Name is the name of the Fleet being scaled</p>
-</td>
-</tr>
-<tr>
-<td>
-<code>namespace</code></br>
+<code>enabled</code></br>
 <em>
-string
+bool
 </em>
 </td>
 <td>
-<p>Namespace is the namespace associated with the request (if any).</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>status</code></br>
+<code>policySelector</code></br>
 <em>
-<a href="#agones.dev/v1.FleetStatus">
-FleetStatus
+<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#labelselector-v1-meta">
+Kubernetes meta/v1.LabelSelector
 </a>
 </em>
 </td>
 <td>
-<p>The Fleet&rsquo;s status values</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="autoscaling.agones.dev/v1.FleetAutoscaleResponse">FleetAutoscaleResponse
+<h3 id="allocation.agones.dev/v1.PlayerSelector">PlayerSelector
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscaleReview">FleetAutoscaleReview</a>)
+<a href="#allocation.agones.dev/v1.GameServerSelector">GameServerSelector</a>)
 </p>
 <p>
-<p>FleetAutoscaleResponse defines the response of webhook autoscaler endpoint</p>
+<p>PlayerSelector is the filter options for a GameServer based on player counts</p>
 </p>
 <table>
 <thead>
@@ -5350,45 +5417,39 @@ <h3 id="autoscaling.agones.dev/v1.FleetAutoscaleResponse">FleetAutoscaleResponse
 <tbody>
 <tr>
 <td>
-<code>uid</code></br>
-<em>
-k8s.io/apimachinery/pkg/types.UID
-</em>
-</td>
-<td>
-<p>UID is an identifier for the individual request/response.
-This should be copied over from the corresponding FleetAutoscaleRequest.</p>
-</td>
-</tr>
-<tr>
-<td>
-<code>scale</code></br>
+<code>minAvailable</code></br>
 <em>
-bool
+int64
 </em>
 </td>
 <td>
-<p>Set to false if no scaling should occur to the Fleet</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>replicas</code></br>
+<code>maxAvailable</code></br>
 <em>
-int32
+int64
 </em>
 </td>
 <td>
-<p>The targeted replica count</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="autoscaling.agones.dev/v1.FleetAutoscaleReview">FleetAutoscaleReview
+<hr/>
+<h2 id="autoscaling.agones.dev/v1">autoscaling.agones.dev/v1</h2>
+<p>
+<p>Package v1 is the v1 version of the API.</p>
+</p>
+Resource Types:
+<ul><li>
+<a href="#autoscaling.agones.dev/v1.FleetAutoscaler">FleetAutoscaler</a>
+</li></ul>
+<h3 id="autoscaling.agones.dev/v1.FleetAutoscaler">FleetAutoscaler
 </h3>
 <p>
-<p>FleetAutoscaleReview is passed to the webhook with a populated Request value,
-and then returned with a populated Response.</p>
+<p>FleetAutoscaler is the data structure for a FleetAutoscaler resource</p>
 </p>
 <table>
 <thead>
@@ -5400,108 +5461,112 @@ <h3 id="autoscaling.agones.dev/v1.FleetAutoscaleReview">FleetAutoscaleReview
 <tbody>
 <tr>
 <td>
-<code>request</code></br>
+<code>apiVersion</code></br>
+string</td>
+<td>
+<code>
+autoscaling.agones.dev/v1
+</code>
+</td>
+</tr>
+<tr>
+<td>
+<code>kind</code></br>
+string
+</td>
+<td><code>FleetAutoscaler</code></td>
+</tr>
+<tr>
+<td>
+<code>metadata</code></br>
 <em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscaleRequest">
-FleetAutoscaleRequest
+<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#objectmeta-v1-meta">
+Kubernetes meta/v1.ObjectMeta
 </a>
 </em>
 </td>
 <td>
+Refer to the Kubernetes API documentation for the fields of the
+<code>metadata</code> field.
 </td>
 </tr>
 <tr>
 <td>
-<code>response</code></br>
+<code>spec</code></br>
 <em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscaleResponse">
-FleetAutoscaleResponse
+<a href="#autoscaling.agones.dev/v1.FleetAutoscalerSpec">
+FleetAutoscalerSpec
 </a>
 </em>
 </td>
 <td>
-</td>
-</tr>
-</tbody>
-</table>
-<h3 id="autoscaling.agones.dev/v1.FleetAutoscalerPolicy">FleetAutoscalerPolicy
-</h3>
-<p>
-(<em>Appears on:</em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscalerSpec">FleetAutoscalerSpec</a>)
-</p>
-<p>
-<p>FleetAutoscalerPolicy describes how to scale a fleet</p>
-</p>
+<br/>
+<br/>
 <table>
-<thead>
 <tr>
-<th>Field</th>
-<th>Description</th>
+<td>
+<code>fleetName</code></br>
+<em>
+string
+</em>
+</td>
+<td>
+</td>
 </tr>
-</thead>
-<tbody>
 <tr>
 <td>
-<code>type</code></br>
+<code>policy</code></br>
 <em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscalerPolicyType">
-FleetAutoscalerPolicyType
+<a href="#autoscaling.agones.dev/v1.FleetAutoscalerPolicy">
+FleetAutoscalerPolicy
 </a>
 </em>
 </td>
 <td>
-<p>Type of autoscaling policy.</p>
+<p>Autoscaling policy</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>buffer</code></br>
+<code>sync</code></br>
 <em>
-<a href="#autoscaling.agones.dev/v1.BufferPolicy">
-BufferPolicy
+<a href="#autoscaling.agones.dev/v1.FleetAutoscalerSync">
+FleetAutoscalerSync
 </a>
 </em>
 </td>
 <td>
 <em>(Optional)</em>
-<p>Buffer policy config params. Present only if FleetAutoscalerPolicyType = Buffer.</p>
+<p>[Stage:Beta]
+[FeatureFlag:CustomFasSyncInterval]
+Sync defines when FleetAutoscalers runs autoscaling</p>
+</td>
+</tr>
+</table>
 </td>
 </tr>
 <tr>
 <td>
-<code>webhook</code></br>
+<code>status</code></br>
 <em>
-<a href="#autoscaling.agones.dev/v1.WebhookPolicy">
-WebhookPolicy
+<a href="#autoscaling.agones.dev/v1.FleetAutoscalerStatus">
+FleetAutoscalerStatus
 </a>
 </em>
 </td>
 <td>
-<em>(Optional)</em>
-<p>Webhook policy config params. Present only if FleetAutoscalerPolicyType = Webhook.</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="autoscaling.agones.dev/v1.FleetAutoscalerPolicyType">FleetAutoscalerPolicyType
-(<code>string</code> alias)</p></h3>
-<p>
-(<em>Appears on:</em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscalerPolicy">FleetAutoscalerPolicy</a>)
-</p>
-<p>
-<p>FleetAutoscalerPolicyType is the policy for autoscaling
-for a given Fleet</p>
-</p>
-<h3 id="autoscaling.agones.dev/v1.FleetAutoscalerSpec">FleetAutoscalerSpec
+<h3 id="autoscaling.agones.dev/v1.BufferPolicy">BufferPolicy
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscaler">FleetAutoscaler</a>)
+<a href="#autoscaling.agones.dev/v1.FleetAutoscalerPolicy">FleetAutoscalerPolicy</a>)
 </p>
 <p>
-<p>FleetAutoscalerSpec is the spec for a Fleet Scaler</p>
+<p>BufferPolicy controls the desired behavior of the buffer policy.</p>
 </p>
 <table>
 <thead>
@@ -5513,53 +5578,59 @@ <h3 id="autoscaling.agones.dev/v1.FleetAutoscalerSpec">FleetAutoscalerSpec
 <tbody>
 <tr>
 <td>
-<code>fleetName</code></br>
+<code>maxReplicas</code></br>
 <em>
-string
+int32
 </em>
 </td>
 <td>
+<p>MaxReplicas is the maximum amount of replicas that the fleet may have.
+It must be bigger than both MinReplicas and BufferSize</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>policy</code></br>
+<code>minReplicas</code></br>
 <em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscalerPolicy">
-FleetAutoscalerPolicy
-</a>
+int32
 </em>
 </td>
 <td>
-<p>Autoscaling policy</p>
+<p>MinReplicas is the minimum amount of replicas that the fleet must have
+If zero, it is ignored.
+If non zero, it must be smaller than MaxReplicas and bigger than BufferSize</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>sync</code></br>
+<code>bufferSize</code></br>
 <em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscalerSync">
-FleetAutoscalerSync
-</a>
+k8s.io/apimachinery/pkg/util/intstr.IntOrString
 </em>
 </td>
 <td>
-<em>(Optional)</em>
-<p>[Stage:Beta]
-[FeatureFlag:CustomFasSyncInterval]
-Sync defines when FleetAutoscalers runs autoscaling</p>
+<p>BufferSize defines how many replicas the autoscaler tries to have ready all the time
+Value can be an absolute number (ex: 5) or a percentage of desired gs instances (ex: 15%)
+Absolute number is calculated from percentage by rounding up.
+Example: when this is set to 20%, the autoscaler will make sure that 20%
+of the fleet&rsquo;s game server replicas are ready. When this is set to 20,
+the autoscaler will make sure that there are 20 available game servers
+Must be bigger than 0
+Note: by &ldquo;ready&rdquo; we understand in this case &ldquo;non-allocated&rdquo;; this is done to ensure robustness
+and computation stability in different edge case (fleet just created, not enough
+capacity in the cluster etc)</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="autoscaling.agones.dev/v1.FleetAutoscalerStatus">FleetAutoscalerStatus
+<h3 id="autoscaling.agones.dev/v1.FixedIntervalSync">FixedIntervalSync
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscaler">FleetAutoscaler</a>)
+<a href="#autoscaling.agones.dev/v1.FleetAutoscalerSync">FleetAutoscalerSync</a>)
 </p>
 <p>
-<p>FleetAutoscalerStatus defines the current status of a FleetAutoscaler</p>
+<p>FixedIntervalSync controls the desired behavior of the fixed interval based sync.</p>
 </p>
 <table>
 <thead>
@@ -5571,75 +5642,93 @@ <h3 id="autoscaling.agones.dev/v1.FleetAutoscalerStatus">FleetAutoscalerStatus
 <tbody>
 <tr>
 <td>
-<code>currentReplicas</code></br>
+<code>seconds</code></br>
 <em>
 int32
 </em>
 </td>
 <td>
-<p>CurrentReplicas is the current number of gameserver replicas
-of the fleet managed by this autoscaler, as last seen by the autoscaler</p>
+<p>Seconds defines how often we run fleet autoscaling in seconds</p>
 </td>
 </tr>
+</tbody>
+</table>
+<h3 id="autoscaling.agones.dev/v1.FleetAutoscaleRequest">FleetAutoscaleRequest
+</h3>
+<p>
+(<em>Appears on:</em>
+<a href="#autoscaling.agones.dev/v1.FleetAutoscaleReview">FleetAutoscaleReview</a>)
+</p>
+<p>
+<p>FleetAutoscaleRequest defines the request to webhook autoscaler endpoint</p>
+</p>
+<table>
+<thead>
+<tr>
+<th>Field</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
 <tr>
 <td>
-<code>desiredReplicas</code></br>
+<code>uid</code></br>
 <em>
-int32
+k8s.io/apimachinery/pkg/types.UID
 </em>
 </td>
 <td>
-<p>DesiredReplicas is the desired number of gameserver replicas
-of the fleet managed by this autoscaler, as last calculated by the autoscaler</p>
+<p>UID is an identifier for the individual request/response. It allows us to distinguish instances of requests which are
+otherwise identical (parallel requests, requests when earlier requests did not modify etc)
+The UID is meant to track the round trip (request/response) between the Autoscaler and the WebHook, not the user request.
+It is suitable for correlating log entries between the webhook and apiserver, for either auditing or debugging.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>lastScaleTime</code></br>
+<code>name</code></br>
 <em>
-<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#time-v1-meta">
-Kubernetes meta/v1.Time
-</a>
+string
 </em>
 </td>
 <td>
-<em>(Optional)</em>
-<p>lastScaleTime is the last time the FleetAutoscaler scaled the attached fleet,</p>
+<p>Name is the name of the Fleet being scaled</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>ableToScale</code></br>
+<code>namespace</code></br>
 <em>
-bool
+string
 </em>
 </td>
 <td>
-<p>AbleToScale indicates that we can access the target fleet</p>
+<p>Namespace is the namespace associated with the request (if any).</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>scalingLimited</code></br>
+<code>status</code></br>
 <em>
-bool
+<a href="#agones.dev/v1.FleetStatus">
+FleetStatus
+</a>
 </em>
 </td>
 <td>
-<p>ScalingLimited indicates that the calculated scale would be above or below the range
-defined by MinReplicas and MaxReplicas, and has thus been capped.</p>
+<p>The Fleet&rsquo;s status values</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="autoscaling.agones.dev/v1.FleetAutoscalerSync">FleetAutoscalerSync
+<h3 id="autoscaling.agones.dev/v1.FleetAutoscaleResponse">FleetAutoscaleResponse
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscalerSpec">FleetAutoscalerSpec</a>)
+<a href="#autoscaling.agones.dev/v1.FleetAutoscaleReview">FleetAutoscaleReview</a>)
 </p>
 <p>
-<p>FleetAutoscalerSync describes when to sync a fleet</p>
+<p>FleetAutoscaleResponse defines the response of webhook autoscaler endpoint</p>
 </p>
 <table>
 <thead>
@@ -5651,52 +5740,45 @@ <h3 id="autoscaling.agones.dev/v1.FleetAutoscalerSync">FleetAutoscalerSync
 <tbody>
 <tr>
 <td>
-<code>type</code></br>
+<code>uid</code></br>
 <em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscalerSyncType">
-FleetAutoscalerSyncType
-</a>
+k8s.io/apimachinery/pkg/types.UID
 </em>
 </td>
 <td>
-<p>Type of autoscaling sync.</p>
+<p>UID is an identifier for the individual request/response.
+This should be copied over from the corresponding FleetAutoscaleRequest.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>fixedInterval</code></br>
+<code>scale</code></br>
 <em>
-<a href="#autoscaling.agones.dev/v1.FixedIntervalSync">
-FixedIntervalSync
-</a>
+bool
 </em>
 </td>
 <td>
-<em>(Optional)</em>
-<p>FixedInterval config params. Present only if FleetAutoscalerSyncType = FixedInterval.</p>
+<p>Set to false if no scaling should occur to the Fleet</p>
+</td>
+</tr>
+<tr>
+<td>
+<code>replicas</code></br>
+<em>
+int32
+</em>
+</td>
+<td>
+<p>The targeted replica count</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="autoscaling.agones.dev/v1.FleetAutoscalerSyncType">FleetAutoscalerSyncType
-(<code>string</code> alias)</p></h3>
-<p>
-(<em>Appears on:</em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscalerSync">FleetAutoscalerSync</a>)
-</p>
-<p>
-<p>FleetAutoscalerSyncType is the sync strategy for a given Fleet</p>
-</p>
-<h3 id="autoscaling.agones.dev/v1.WebhookPolicy">WebhookPolicy
+<h3 id="autoscaling.agones.dev/v1.FleetAutoscaleReview">FleetAutoscaleReview
 </h3>
 <p>
-(<em>Appears on:</em>
-<a href="#autoscaling.agones.dev/v1.FleetAutoscalerPolicy">FleetAutoscalerPolicy</a>)
-</p>
-<p>
-<p>WebhookPolicy controls the desired behavior of the webhook policy.
-It contains the description of the webhook autoscaler service
-used to form url which is accessible inside the cluster</p>
+<p>FleetAutoscaleReview is passed to the webhook with a populated Request value,
+and then returned with a populated Response.</p>
 </p>
 <table>
 <thead>
@@ -5708,79 +5790,38 @@ <h3 id="autoscaling.agones.dev/v1.WebhookPolicy">WebhookPolicy
 <tbody>
 <tr>
 <td>
-<code>url</code></br>
-<em>
-string
-</em>
-</td>
-<td>
-<em>(Optional)</em>
-<p><code>url</code> gives the location of the webhook, in standard URL form
-(<code>scheme://host:port/path</code>). Exactly one of <code>url</code> or <code>service</code>
-must be specified.</p>
-<p>The <code>host</code> should not refer to a service running in the cluster; use
-the <code>service</code> field instead. The host might be resolved via external
-DNS in some apiservers (e.g., <code>kube-apiserver</code> cannot resolve
-in-cluster DNS as that would be a layering violation). <code>host</code> may
-also be an IP address.</p>
-<p>Please note that using <code>localhost</code> or <code>127.0.0.1</code> as a <code>host</code> is
-risky unless you take great care to run this webhook on all hosts
-which run an apiserver which might need to make calls to this
-webhook. Such installs are likely to be non-portable, i.e., not easy
-to turn up in a new cluster.</p>
-<p>The scheme must be &ldquo;https&rdquo;; the URL must begin with &ldquo;https://&rdquo;.</p>
-<p>A path is optional, and if present may be any string permissible in
-a URL. You may use the path to pass an arbitrary string to the
-webhook, for example, a cluster identifier.</p>
-<p>Attempting to use a user or basic auth e.g. &ldquo;user:password@&rdquo; is not
-allowed. Fragments (&ldquo;#&hellip;&rdquo;) and query parameters (&ldquo;?&hellip;&rdquo;) are not
-allowed, either.</p>
-</td>
-</tr>
-<tr>
-<td>
-<code>service</code></br>
+<code>request</code></br>
 <em>
-<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#servicereference-v1-admissionregistration">
-Kubernetes admissionregistration/v1.ServiceReference
+<a href="#autoscaling.agones.dev/v1.FleetAutoscaleRequest">
+FleetAutoscaleRequest
 </a>
 </em>
 </td>
 <td>
-<em>(Optional)</em>
-<p><code>service</code> is a reference to the service for this webhook. Either
-<code>service</code> or <code>url</code> must be specified.</p>
-<p>If the webhook is running within the cluster, then you should use <code>service</code>.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>caBundle</code></br>
+<code>response</code></br>
 <em>
-[]byte
+<a href="#autoscaling.agones.dev/v1.FleetAutoscaleResponse">
+FleetAutoscaleResponse
+</a>
 </em>
 </td>
 <td>
-<em>(Optional)</em>
-<p><code>caBundle</code> is a PEM encoded CA bundle which will be used to validate the webhook&rsquo;s server certificate.
-If unspecified, system trust roots on the apiserver are used.</p>
 </td>
 </tr>
 </tbody>
 </table>
-<hr/>
-<h2 id="multicluster.agones.dev/v1">multicluster.agones.dev/v1</h2>
+<h3 id="autoscaling.agones.dev/v1.FleetAutoscalerPolicy">FleetAutoscalerPolicy
+</h3>
 <p>
-<p>Package v1 is the v1 version of the API.</p>
+(<em>Appears on:</em>
+<a href="#autoscaling.agones.dev/v1.FleetAutoscalerSpec">FleetAutoscalerSpec</a>)
 </p>
-Resource Types:
-<ul><li>
-<a href="#multicluster.agones.dev/v1.GameServerAllocationPolicy">GameServerAllocationPolicy</a>
-</li></ul>
-<h3 id="multicluster.agones.dev/v1.GameServerAllocationPolicy">GameServerAllocationPolicy
-</h3>
 <p>
-<p>GameServerAllocationPolicy is the Schema for the gameserverallocationpolicies API</p>
+<p>FleetAutoscalerPolicy describes how to scale a fleet</p>
 </p>
 <table>
 <thead>
@@ -5792,53 +5833,79 @@ <h3 id="multicluster.agones.dev/v1.GameServerAllocationPolicy">GameServerAllocat
 <tbody>
 <tr>
 <td>
-<code>apiVersion</code></br>
-string</td>
-<td>
-<code>
-multicluster.agones.dev/v1
-</code>
+<code>type</code></br>
+<em>
+<a href="#autoscaling.agones.dev/v1.FleetAutoscalerPolicyType">
+FleetAutoscalerPolicyType
+</a>
+</em>
 </td>
-</tr>
-<tr>
 <td>
-<code>kind</code></br>
-string
+<p>Type of autoscaling policy.</p>
 </td>
-<td><code>GameServerAllocationPolicy</code></td>
 </tr>
 <tr>
 <td>
-<code>metadata</code></br>
+<code>buffer</code></br>
 <em>
-<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#objectmeta-v1-meta">
-Kubernetes meta/v1.ObjectMeta
+<a href="#autoscaling.agones.dev/v1.BufferPolicy">
+BufferPolicy
 </a>
 </em>
 </td>
 <td>
-Refer to the Kubernetes API documentation for the fields of the
-<code>metadata</code> field.
+<em>(Optional)</em>
+<p>Buffer policy config params. Present only if FleetAutoscalerPolicyType = Buffer.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>spec</code></br>
+<code>webhook</code></br>
 <em>
-<a href="#multicluster.agones.dev/v1.GameServerAllocationPolicySpec">
-GameServerAllocationPolicySpec
+<a href="#autoscaling.agones.dev/v1.WebhookPolicy">
+WebhookPolicy
 </a>
 </em>
 </td>
 <td>
-<br/>
-<br/>
+<em>(Optional)</em>
+<p>Webhook policy config params. Present only if FleetAutoscalerPolicyType = Webhook.</p>
+</td>
+</tr>
+</tbody>
+</table>
+<h3 id="autoscaling.agones.dev/v1.FleetAutoscalerPolicyType">FleetAutoscalerPolicyType
+(<code>string</code> alias)</p></h3>
+<p>
+(<em>Appears on:</em>
+<a href="#autoscaling.agones.dev/v1.FleetAutoscalerPolicy">FleetAutoscalerPolicy</a>)
+</p>
+<p>
+<p>FleetAutoscalerPolicyType is the policy for autoscaling
+for a given Fleet</p>
+</p>
+<h3 id="autoscaling.agones.dev/v1.FleetAutoscalerSpec">FleetAutoscalerSpec
+</h3>
+<p>
+(<em>Appears on:</em>
+<a href="#autoscaling.agones.dev/v1.FleetAutoscaler">FleetAutoscaler</a>)
+</p>
+<p>
+<p>FleetAutoscalerSpec is the spec for a Fleet Scaler</p>
+</p>
 <table>
+<thead>
+<tr>
+<th>Field</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
 <tr>
 <td>
-<code>priority</code></br>
+<code>fleetName</code></br>
 <em>
-int32
+string
 </em>
 </td>
 <td>
@@ -5846,39 +5913,43 @@ <h3 id="multicluster.agones.dev/v1.GameServerAllocationPolicy">GameServerAllocat
 </tr>
 <tr>
 <td>
-<code>weight</code></br>
+<code>policy</code></br>
 <em>
-int
+<a href="#autoscaling.agones.dev/v1.FleetAutoscalerPolicy">
+FleetAutoscalerPolicy
+</a>
 </em>
 </td>
 <td>
+<p>Autoscaling policy</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>connectionInfo</code></br>
+<code>sync</code></br>
 <em>
-<a href="#multicluster.agones.dev/v1.ClusterConnectionInfo">
-ClusterConnectionInfo
+<a href="#autoscaling.agones.dev/v1.FleetAutoscalerSync">
+FleetAutoscalerSync
 </a>
 </em>
 </td>
 <td>
-</td>
-</tr>
-</table>
+<em>(Optional)</em>
+<p>[Stage:Beta]
+[FeatureFlag:CustomFasSyncInterval]
+Sync defines when FleetAutoscalers runs autoscaling</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="multicluster.agones.dev/v1.ClusterConnectionInfo">ClusterConnectionInfo
+<h3 id="autoscaling.agones.dev/v1.FleetAutoscalerStatus">FleetAutoscalerStatus
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#multicluster.agones.dev/v1.GameServerAllocationPolicySpec">GameServerAllocationPolicySpec</a>)
+<a href="#autoscaling.agones.dev/v1.FleetAutoscaler">FleetAutoscaler</a>)
 </p>
 <p>
-<p>ClusterConnectionInfo defines the connection information for a cluster</p>
+<p>FleetAutoscalerStatus defines the current status of a FleetAutoscaler</p>
 </p>
 <table>
 <thead>
@@ -5890,67 +5961,75 @@ <h3 id="multicluster.agones.dev/v1.ClusterConnectionInfo">ClusterConnectionInfo
 <tbody>
 <tr>
 <td>
-<code>clusterName</code></br>
+<code>currentReplicas</code></br>
 <em>
-string
+int32
 </em>
 </td>
 <td>
-<p>Optional: the name of the targeted cluster</p>
+<p>CurrentReplicas is the current number of gameserver replicas
+of the fleet managed by this autoscaler, as last seen by the autoscaler</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>allocationEndpoints</code></br>
+<code>desiredReplicas</code></br>
 <em>
-[]string
+int32
 </em>
 </td>
 <td>
-<p>The endpoints for the allocator service in the targeted cluster.
-If the AllocationEndpoints is not set, the allocation happens on local cluster.
-If there are multiple endpoints any of the endpoints that can handle allocation request should suffice</p>
+<p>DesiredReplicas is the desired number of gameserver replicas
+of the fleet managed by this autoscaler, as last calculated by the autoscaler</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>secretName</code></br>
+<code>lastScaleTime</code></br>
 <em>
-string
+<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#time-v1-meta">
+Kubernetes meta/v1.Time
+</a>
 </em>
 </td>
 <td>
-<p>The name of the secret that contains TLS client certificates to connect the allocator server in the targeted cluster</p>
+<em>(Optional)</em>
+<p>lastScaleTime is the last time the FleetAutoscaler scaled the attached fleet,</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>namespace</code></br>
+<code>ableToScale</code></br>
 <em>
-string
+bool
 </em>
 </td>
 <td>
-<p>The cluster namespace from which to allocate gameservers</p>
+<p>AbleToScale indicates that we can access the target fleet</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>serverCa</code></br>
+<code>scalingLimited</code></br>
 <em>
-[]byte
+bool
 </em>
 </td>
 <td>
-<p>The PEM encoded server CA, used by the allocator client to authenticate the remote server.</p>
+<p>ScalingLimited indicates that the calculated scale would be above or below the range
+defined by MinReplicas and MaxReplicas, and has thus been capped.</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="multicluster.agones.dev/v1.ConnectionInfoIterator">ConnectionInfoIterator
+<h3 id="autoscaling.agones.dev/v1.FleetAutoscalerSync">FleetAutoscalerSync
 </h3>
 <p>
-<p>ConnectionInfoIterator an iterator on ClusterConnectionInfo</p>
+(<em>Appears on:</em>
+<a href="#autoscaling.agones.dev/v1.FleetAutoscalerSpec">FleetAutoscalerSpec</a>)
+</p>
+<p>
+<p>FleetAutoscalerSync describes when to sync a fleet</p>
 </p>
 <table>
 <thead>
@@ -5962,58 +6041,52 @@ <h3 id="multicluster.agones.dev/v1.ConnectionInfoIterator">ConnectionInfoIterato
 <tbody>
 <tr>
 <td>
-<code>currPriority</code></br>
-<em>
-int
-</em>
-</td>
-<td>
-<p>currPriority Current priority index from the orderedPriorities</p>
-</td>
-</tr>
-<tr>
-<td>
-<code>orderedPriorities</code></br>
-<em>
-[]int32
-</em>
-</td>
-<td>
-<p>orderedPriorities list of ordered priorities</p>
-</td>
-</tr>
-<tr>
-<td>
-<code>priorityToCluster</code></br>
+<code>type</code></br>
 <em>
-map[int32]map[string][]*agones.dev/agones/pkg/apis/multicluster/v1.GameServerAllocationPolicy
+<a href="#autoscaling.agones.dev/v1.FleetAutoscalerSyncType">
+FleetAutoscalerSyncType
+</a>
 </em>
 </td>
 <td>
-<p>priorityToCluster Map of priority to cluster-policies map</p>
+<p>Type of autoscaling sync.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>clusterBlackList</code></br>
+<code>fixedInterval</code></br>
 <em>
-map[string]bool
+<a href="#autoscaling.agones.dev/v1.FixedIntervalSync">
+FixedIntervalSync
+</a>
 </em>
 </td>
 <td>
-<p>clusterBlackList the cluster blacklist for the clusters that has already returned</p>
+<em>(Optional)</em>
+<p>FixedInterval config params. Present only if FleetAutoscalerSyncType = FixedInterval.</p>
 </td>
 </tr>
 </tbody>
 </table>
-<h3 id="multicluster.agones.dev/v1.GameServerAllocationPolicySpec">GameServerAllocationPolicySpec
+<h3 id="autoscaling.agones.dev/v1.FleetAutoscalerSyncType">FleetAutoscalerSyncType
+(<code>string</code> alias)</p></h3>
+<p>
+(<em>Appears on:</em>
+<a href="#autoscaling.agones.dev/v1.FleetAutoscalerSync">FleetAutoscalerSync</a>)
+</p>
+<p>
+<p>FleetAutoscalerSyncType is the sync strategy for a given Fleet</p>
+</p>
+<h3 id="autoscaling.agones.dev/v1.WebhookPolicy">WebhookPolicy
 </h3>
 <p>
 (<em>Appears on:</em>
-<a href="#multicluster.agones.dev/v1.GameServerAllocationPolicy">GameServerAllocationPolicy</a>)
+<a href="#autoscaling.agones.dev/v1.FleetAutoscalerPolicy">FleetAutoscalerPolicy</a>)
 </p>
 <p>
-<p>GameServerAllocationPolicySpec defines the desired state of GameServerAllocationPolicy</p>
+<p>WebhookPolicy controls the desired behavior of the webhook policy.
+It contains the description of the webhook autoscaler service
+used to form url which is accessible inside the cluster</p>
 </p>
 <table>
 <thead>
@@ -6025,34 +6098,62 @@ <h3 id="multicluster.agones.dev/v1.GameServerAllocationPolicySpec">GameServerAll
 <tbody>
 <tr>
 <td>
-<code>priority</code></br>
+<code>url</code></br>
 <em>
-int32
+string
 </em>
 </td>
 <td>
+<em>(Optional)</em>
+<p><code>url</code> gives the location of the webhook, in standard URL form
+(<code>scheme://host:port/path</code>). Exactly one of <code>url</code> or <code>service</code>
+must be specified.</p>
+<p>The <code>host</code> should not refer to a service running in the cluster; use
+the <code>service</code> field instead. The host might be resolved via external
+DNS in some apiservers (e.g., <code>kube-apiserver</code> cannot resolve
+in-cluster DNS as that would be a layering violation). <code>host</code> may
+also be an IP address.</p>
+<p>Please note that using <code>localhost</code> or <code>127.0.0.1</code> as a <code>host</code> is
+risky unless you take great care to run this webhook on all hosts
+which run an apiserver which might need to make calls to this
+webhook. Such installs are likely to be non-portable, i.e., not easy
+to turn up in a new cluster.</p>
+<p>The scheme must be &ldquo;https&rdquo;; the URL must begin with &ldquo;https://&rdquo;.</p>
+<p>A path is optional, and if present may be any string permissible in
+a URL. You may use the path to pass an arbitrary string to the
+webhook, for example, a cluster identifier.</p>
+<p>Attempting to use a user or basic auth e.g. &ldquo;user:password@&rdquo; is not
+allowed. Fragments (&ldquo;#&hellip;&rdquo;) and query parameters (&ldquo;?&hellip;&rdquo;) are not
+allowed, either.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>weight</code></br>
+<code>service</code></br>
 <em>
-int
+<a href="https://v1-23.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#servicereference-v1-admissionregistration">
+Kubernetes admissionregistration/v1.ServiceReference
+</a>
 </em>
 </td>
 <td>
+<em>(Optional)</em>
+<p><code>service</code> is a reference to the service for this webhook. Either
+<code>service</code> or <code>url</code> must be specified.</p>
+<p>If the webhook is running within the cluster, then you should use <code>service</code>.</p>
 </td>
 </tr>
 <tr>
 <td>
-<code>connectionInfo</code></br>
+<code>caBundle</code></br>
 <em>
-<a href="#multicluster.agones.dev/v1.ClusterConnectionInfo">
-ClusterConnectionInfo
-</a>
+[]byte
 </em>
 </td>
 <td>
+<em>(Optional)</em>
+<p><code>caBundle</code> is a PEM encoded CA bundle which will be used to validate the webhook&rsquo;s server certificate.
+If unspecified, system trust roots on the apiserver are used.</p>
 </td>
 </tr>
 </tbody>