feat(gantry): make the agent DaemonSet update strategy configurable

The agent DaemonSet hard-codes maxUnavailable: 50%, so every rollout
replaces half of a cluster's agents at once. Expose updateStrategy as a
value so installers on large clusters can bound how many nodes lose their
local mirror during a rollout. The default is unchanged.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 866228da-74dc-450c-9aa8-e22099bbd779

Author: Masatoshi Tanida

deploy/gantry/README.md

@@ -90,6 +90,16 @@ Do not combine these stages in one Helm upgrade. A new pod can create a
 higher-numbered Lease while old pods are still running, which makes the old
 pods reject their next chair snapshot.
 
+## Agent rollout
+
+`updateStrategy` is the agent DaemonSet's update strategy. The default
+`maxUnavailable: 50%` replaces half of the agents at once; lower it on large
+clusters to bound how many nodes lose their local mirror during a rollout:
+
+```sh
+--set-string updateStrategy.rollingUpdate.maxUnavailable=10%
+```
+
 ## Operator Profile
 
 ```sh

deploy/gantry/chart/templates/daemonset.yaml

@@ -12,9 +12,7 @@ spec:
     matchLabels:
       app.kubernetes.io/name: gantry
   updateStrategy:
-    type: RollingUpdate
-    rollingUpdate:
-      maxUnavailable: 50%
+    {{- toYaml .Values.updateStrategy | nindent 4 }}
   template:
     metadata:
       labels:

deploy/gantry/chart/values.schema.json

@@ -6,6 +6,7 @@
     "image",
     "namespace",
     "manager",
+    "updateStrategy",
     "nodeSelector",
     "tolerations",
     "containerd",
@@ -68,6 +69,52 @@
         "helm"
       ]
     },
+    "updateStrategy": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "type"
+      ],
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": [
+            "RollingUpdate",
+            "OnDelete"
+          ]
+        },
+        "rollingUpdate": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "maxUnavailable": {
+              "anyOf": [
+                {
+                  "type": "integer",
+                  "minimum": 1
+                },
+                {
+                  "type": "string",
+                  "pattern": "^([1-9][0-9]?|100)%$"
+                }
+              ]
+            },
+            "maxSurge": {
+              "anyOf": [
+                {
+                  "type": "integer",
+                  "minimum": 0
+                },
+                {
+                  "type": "string",
+                  "pattern": "^([0-9]|[1-9][0-9]|100)%$"
+                }
+              ]
+            }
+          }
+        }
+      }
+    },
     "nodeSelector": {
       "type": "object",
       "required": [

deploy/gantry/chart/values.yaml

@@ -10,6 +10,13 @@ namespace:
 
 manager: helm
 
+# Rollout strategy for the agent DaemonSet. Lower maxUnavailable on large
+# clusters to bound how many nodes lose the local mirror at once.
+updateStrategy:
+  type: RollingUpdate
+  rollingUpdate:
+    maxUnavailable: 50%
+
 nodeSelector:
   kubernetes.io/os: linux
 

deploy/gantry/render_test.go

@@ -157,6 +157,36 @@ func TestRendersFixedChairLeaseSet(t *testing.T) {
 	}
 }
 
+func TestRendersConfiguredAgentUpdateStrategy(t *testing.T) {
+	t.Parallel()
+
+	for _, tc := range []struct {
+		name string
+		args []string
+		want string
+	}{
+		{name: "default", want: "maxUnavailable: 50%"},
+		{
+			name: "override",
+			args: []string{"--set-string", "updateStrategy.rollingUpdate.maxUnavailable=10%"},
+			want: "maxUnavailable: 10%",
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			raw, err := os.ReadFile(filepath.Join(renderChart(t, false, tc.args...), "daemonset.yaml"))
+			if err != nil {
+				t.Fatalf("read rendered agent DaemonSet: %v", err)
+			}
+
+			if !bytes.Contains(raw, []byte(tc.want)) {
+				t.Fatalf("rendered agent DaemonSet does not contain %q", tc.want)
+			}
+		})
+	}
+}
+
 func TestRendersConfiguredChairAndSeedCounts(t *testing.T) {
 	t.Parallel()