OCP 4.20 and earlier cluster should have AutoSizingReserved disable by default

Author: ngopalak-redhat

pkg/controller/kubelet-config/kubelet_config_nodes.go

@@ -21,6 +21,14 @@ import (
 	"k8s.io/klog/v2"
 )
 
+const (
+	DefaultAutoSizingEnvContent = `NODE_SIZING_ENABLED=false
+SYSTEM_RESERVED_MEMORY=1Gi
+SYSTEM_RESERVED_CPU=500m
+SYSTEM_RESERVED_ES=1Gi
+`
+)
+
 func (ctrl *Controller) nodeConfigWorker() {
 	for ctrl.processNextNodeConfigWorkItem() {
 	}
@@ -56,6 +64,62 @@ func (ctrl *Controller) handleNodeConfigErr(err error, key string) {
 	ctrl.nodeConfigQueue.AddAfter(key, 1*time.Minute)
 }
 
+// newAutoSizingMachineConfig creates an empty auto-sizing MachineConfig for a given pool
+func newAutoSizingMachineConfig(pool *mcfgv1.MachineConfigPool) (*mcfgv1.MachineConfig, error) {
+	autoSizingDisabledName := fmt.Sprintf("01-%s-auto-sizing-disabled", pool.Name)
+	ignConfig := ctrlcommon.NewIgnConfig()
+	autoSizingMC, err := ctrlcommon.MachineConfigFromIgnConfig(pool.Name, autoSizingDisabledName, ignConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create the auto-sizing disabled file
+	autoSizingFile := ctrlcommon.NewIgnFileBytes("/etc/node-sizing-enabled.env", []byte(DefaultAutoSizingEnvContent))
+	autoSizingIgnConfig := ctrlcommon.NewIgnConfig()
+	autoSizingIgnConfig.Storage.Files = append(autoSizingIgnConfig.Storage.Files, autoSizingFile)
+	rawAutoSizingIgn, err := json.Marshal(autoSizingIgnConfig)
+	if err != nil {
+		return nil, err
+	}
+	autoSizingMC.Spec.Config.Raw = rawAutoSizingIgn
+	// Do not add GeneratedByControllerVersionAnnotationKey annotation to auto-sizing MachineConfig. It will fail upgrade.
+	// This annotation is added for informing the user that the auto-sizing MachineConfig was added in a patch release
+	// to identify clusters created before 4.21 release.
+	autoSizingMC.ObjectMeta.Annotations = map[string]string{
+		"openshift-patch-reference": "added auto-sizing MachineConfig to disable node sizing",
+	}
+
+	return autoSizingMC, nil
+}
+
+// configureAutoSizingMachineConfig creates an auto-sizing MachineConfig for a given pool if it doesn't exist
+func (ctrl *Controller) configureAutoSizingMachineConfig(pool *mcfgv1.MachineConfigPool) error {
+	autoSizingKey := fmt.Sprintf("01-%s-auto-sizing-disabled", pool.Name)
+	_, err := ctrl.client.MachineconfigurationV1().MachineConfigs().Get(context.TODO(), autoSizingKey, metav1.GetOptions{})
+	autoSizingIsNotFound := errors.IsNotFound(err)
+	if err != nil && !autoSizingIsNotFound {
+		return err
+	}
+	// Only create the auto-sizing MachineConfig if it doesn't exist
+	if autoSizingIsNotFound {
+		autoSizingMC, err := newAutoSizingMachineConfig(pool)
+		if err != nil {
+			return err
+		}
+		// Create the auto-sizing MachineConfig
+		if err := retry.RetryOnConflict(updateBackoff, func() error {
+			_, err := ctrl.client.MachineconfigurationV1().MachineConfigs().Create(context.TODO(), autoSizingMC, metav1.CreateOptions{})
+			return err
+		}); err != nil {
+			return fmt.Errorf("Could not Create auto-sizing MachineConfig, error: %w", err)
+		}
+		klog.Infof("Created auto-sizing configuration %v on MachineConfigPool %v", autoSizingKey, pool.Name)
+	} else {
+		klog.V(4).Infof("Auto-sizing MachineConfig %v already exists for pool %v, skipping creation", autoSizingKey, pool.Name)
+	}
+	return nil
+}
+
 // syncNodeConfigHandler syncs whenever there is a change on the nodes.config.openshift.io resource
 // nodes.config.openshift.io object holds the cluster-wide information about the
 // node specific features such as cgroup modes, workerlatencyprofiles, etc.
@@ -93,6 +157,13 @@ func (ctrl *Controller) syncNodeConfigHandler(key string) error {
 		return fmt.Errorf("could not get the TLSSecurityProfile from %v: %v", ctrlcommon.APIServerInstanceName, err)
 	}
 
+	for _, pool := range mcpPools {
+		// First, create the auto-sizing MachineConfig for this pool if it doesn't exist
+		if err := ctrl.configureAutoSizingMachineConfig(pool); err != nil {
+			return err
+		}
+	}
+
 	for _, pool := range mcpPools {
 		role := pool.Name
 		// Get MachineConfig
@@ -278,6 +349,15 @@ func RunNodeConfigBootstrap(templateDir string, fgHandler ctrlcommon.FeatureGate
 
 	configs := []*mcfgv1.MachineConfig{}
 
+	// Create auto-sizing MachineConfigs for each pool
+	for _, pool := range mcpPools {
+		autoSizingMC, err := newAutoSizingMachineConfig(pool)
+		if err != nil {
+			return nil, err
+		}
+		configs = append(configs, autoSizingMC)
+	}
+
 	for _, pool := range mcpPools {
 		role := pool.Name
 		// Get MachineConfig

pkg/controller/kubelet-config/kubelet_config_nodes_test.go

@@ -69,6 +69,12 @@ func TestNodeConfigDefault(t *testing.T) {
 			f.nodeLister = append(f.nodeLister, nodeConfig)
 			f.oseobjects = append(f.oseobjects, nodeConfig)
 
+			// Auto-sizing MC
+			autoSizingKey := fmt.Sprintf("01-%s-auto-sizing", mcp.Name)
+			autoSizingMC := helpers.NewMachineConfig(autoSizingKey, map[string]string{"node-role/worker": ""}, "dummy://", []ign3types.File{{}})
+
+			f.expectGetMachineConfigAction(autoSizingMC)
+			f.expectCreateMachineConfigAction(autoSizingMC)
 			f.expectGetMachineConfigAction(mcs)
 			f.expectGetMachineConfigAction(mcsDeprecated)
 			f.expectGetMachineConfigAction(mcs)
@@ -119,11 +125,18 @@ func TestBootstrapNodeConfigDefault(t *testing.T) {
 						if err != nil {
 							t.Errorf("could not run node config bootstrap: %v", err)
 						}
-						expectedCount := 2
+						// Bootstrap now creates 4 MachineConfigs:
+						// 1. master auto-sizing (01-master-auto-sizing-disabled)
+						// 2. master node config (97-master-generated-kubelet)
+						// 3. worker auto-sizing (01-worker-auto-sizing-disabled)
+						// 4. worker node config (97-worker-generated-kubelet)
+						expectedCount := 4
 						if len(mcs) != expectedCount {
 							t.Errorf("expected %v machine configs generated with the default node config, got %d machine configs", expectedCount, len(mcs))
 						}
-						require.Equal(t, mcs[0].Spec.KernelArguments, expect.MasterKernelArgs)
+						// The kernel args are on the node config MCs (indices 2 and 3)
+						// Order: 0=master auto-sizing, 1=worker auto-sizing, 2=master node config, 3=worker node config
+						require.Equal(t, expect.MasterKernelArgs, mcs[2].Spec.KernelArguments)
 					}
 				})
 			}
@@ -218,8 +231,19 @@ func TestNodeConfigCustom(t *testing.T) {
 
 			mcList, err = c.client.MachineconfigurationV1().MachineConfigs().List(context.TODO(), metav1.ListOptions{})
 			require.NoError(t, err)
-			require.Len(t, mcList.Items, 1)
-			require.NotEqual(t, nodeKeyCustom, mcList.Items[0].Name)
+			// Now expecting 2 MachineConfigs:
+			// 1. Auto-sizing MC for worker (01-worker-auto-sizing-disabled)
+			// 2. Node config MC for worker (97-worker-generated-kubelet)
+			// Note: The pre-existing nodeKeyCustom (97-custom-generated-kubelet) is cleaned up by
+			// cleanUpDuplicatedMC because it was created without the proper annotation
+			require.Len(t, mcList.Items, 2)
+			// Verify both MachineConfigs are present
+			mcNames := make(map[string]bool)
+			for _, mc := range mcList.Items {
+				mcNames[mc.Name] = true
+			}
+			require.True(t, mcNames["01-worker-auto-sizing-disabled"], "Expected 01-worker-auto-sizing-disabled to be created")
+			require.True(t, mcNames["97-worker-generated-kubelet"], "Expected 97-worker-generated-kubelet to be created")
 		})
 	}
 }