karmada operator: add karmada defaults

Signed-off-by: calvin <wen.chen@daocloud.io>

operator/pkg/apis/operator/v1alpha1/defaults.go

@@ -0,0 +1,208 @@
+package v1alpha1
+
+import (
+	"fmt"
+
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/utils/pointer"
+
+	"github.com/karmada-io/karmada/operator/pkg/constants"
+)
+
+var (
+	etcdImageRepository                        = fmt.Sprintf("%s/%s", constants.KubeDefaultRepository, constants.Etcd)
+	karmadaAPIServiceImageRepository           = fmt.Sprintf("%s/%s", constants.KubeDefaultRepository, constants.KarmadaAPIServer)
+	karmadaAggregratedAPIServerImageRepository = fmt.Sprintf("%s/%s", constants.KarmadaDefaultRepository, constants.KarmadaAggregatedAPIServer)
+	kubeControllerManagerImageRepository       = fmt.Sprintf("%s/%s", constants.KubeDefaultRepository, constants.KubeControllerManager)
+	karmadaControllerManagerImageRepository    = fmt.Sprintf("%s/%s", constants.KarmadaDefaultRepository, constants.KarmadaControllerManager)
+	karmadaSchedulerImageRepository            = fmt.Sprintf("%s/%s", constants.KarmadaDefaultRepository, constants.KarmadaScheduler)
+	karmadaWebhookImageRepository              = fmt.Sprintf("%s/%s", constants.KarmadaDefaultRepository, constants.KarmadaWebhook)
+)
+
+func addDefaultingFuncs(scheme *runtime.Scheme) error {
+	return RegisterDefaults(scheme)
+}
+
+// RegisterDefaults adds defaulters functions to the given scheme.
+// Public to allow building arbitrary schemes.
+// All generated defaulters are covering - they call all nested defaulters.
+func RegisterDefaults(scheme *runtime.Scheme) error {
+	scheme.AddTypeDefaultingFunc(&Karmada{}, func(obj interface{}) { SetObjectDefaultsKarmada(obj.(*Karmada)) })
+	return nil
+}
+
+// SetObjectDefaultsKarmada set defaults for karmada
+func SetObjectDefaultsKarmada(in *Karmada) {
+	setDefaultsKarmada(in)
+}
+
+func setDefaultsKarmada(obj *Karmada) {
+	setDefaultsHostCluster(obj)
+	setDefaultsKarmadaComponents(obj)
+}
+
+func setDefaultsKarmadaComponents(obj *Karmada) {
+	if obj.Spec.Components == nil {
+		obj.Spec.Components = &KarmadaComponents{}
+	}
+
+	setDefaultsEtcd(obj.Spec.Components)
+	setDefaultsKarmadaAPIServer(obj.Spec.Components)
+	setDefaultsKarmadaAggregratedAPIServer(obj.Spec.Components)
+	setDefaultsKubeControllerManager(obj.Spec.Components)
+	setDefaultsKarmadaControllerManager(obj.Spec.Components)
+	setDefaultsKarmadaScheduler(obj.Spec.Components)
+	setDefaultsKarmadaWebhook(obj.Spec.Components)
+}
+
+func setDefaultsHostCluster(obj *Karmada) {
+	if obj.Spec.HostCluster == nil {
+		obj.Spec.HostCluster = &HostCluster{}
+	}
+
+	hc := obj.Spec.HostCluster
+	if hc.Networking == nil {
+		hc.Networking = &Networking{}
+	}
+	if hc.Networking.DNSDomain == nil {
+		hc.Networking.DNSDomain = pointer.String(constants.KarmadaDefaultDNSDomain)
+	}
+}
+
+func setDefaultsEtcd(obj *KarmadaComponents) {
+	if obj.Etcd == nil {
+		obj.Etcd = &Etcd{}
+	}
+
+	if obj.Etcd.External == nil {
+		if obj.Etcd.Local == nil {
+			obj.Etcd.Local = &LocalEtcd{}
+		}
+
+		if obj.Etcd.Local.Replicas == nil {
+			obj.Etcd.Local.Replicas = pointer.Int32(1)
+		}
+		if len(obj.Etcd.Local.Image.ImageRepository) == 0 {
+			obj.Etcd.Local.Image.ImageRepository = etcdImageRepository
+		}
+		if len(obj.Etcd.Local.Image.ImageTag) == 0 {
+			obj.Etcd.Local.Image.ImageTag = constants.EtcdDefaultVersion
+		}
+
+		if obj.Etcd.Local.VolumeData == nil {
+			obj.Etcd.Local.VolumeData = &VolumeData{}
+		}
+		if obj.Etcd.Local.VolumeData.EmptyDir == nil && obj.Etcd.Local.VolumeData.HostPath == nil && obj.Etcd.Local.VolumeData.VolumeClaim == nil {
+			obj.Etcd.Local.VolumeData.EmptyDir = &corev1.EmptyDirVolumeSource{}
+		}
+	}
+}
+
+func setDefaultsKarmadaAPIServer(obj *KarmadaComponents) {
+	if obj.KarmadaAPIServer == nil {
+		obj.KarmadaAPIServer = &KarmadaAPIServer{}
+	}
+
+	apiserver := obj.KarmadaAPIServer
+	if len(apiserver.Image.ImageRepository) == 0 {
+		apiserver.Image.ImageRepository = karmadaAPIServiceImageRepository
+	}
+	if len(apiserver.Image.ImageTag) == 0 {
+		apiserver.Image.ImageTag = constants.KubeDefaultVersion
+	}
+	if apiserver.Replicas == nil {
+		apiserver.Replicas = pointer.Int32(1)
+	}
+	if apiserver.ServiceSubnet == nil {
+		apiserver.ServiceSubnet = pointer.String(constants.KarmadaDefaultServiceSubnet)
+	}
+	if len(apiserver.ServiceType) == 0 {
+		apiserver.ServiceType = corev1.ServiceTypeClusterIP
+	}
+}
+
+func setDefaultsKarmadaAggregratedAPIServer(obj *KarmadaComponents) {
+	if obj.KarmadaAggregratedAPIServer == nil {
+		obj.KarmadaAggregratedAPIServer = &KarmadaAggregratedAPIServer{}
+	}
+
+	aggregrated := obj.KarmadaAggregratedAPIServer
+	if len(aggregrated.Image.ImageRepository) == 0 {
+		aggregrated.Image.ImageRepository = karmadaAggregratedAPIServerImageRepository
+	}
+	if len(aggregrated.Image.ImageTag) == 0 {
+		aggregrated.Image.ImageTag = constants.KarmadaDefaultVersion
+	}
+	if aggregrated.Replicas == nil {
+		aggregrated.Replicas = pointer.Int32(1)
+	}
+}
+
+func setDefaultsKubeControllerManager(obj *KarmadaComponents) {
+	if obj.KubeControllerManager == nil {
+		obj.KubeControllerManager = &KubeControllerManager{}
+	}
+
+	kubeControllerManager := obj.KubeControllerManager
+	if len(kubeControllerManager.Image.ImageRepository) == 0 {
+		kubeControllerManager.Image.ImageRepository = kubeControllerManagerImageRepository
+	}
+	if len(kubeControllerManager.Image.ImageTag) == 0 {
+		kubeControllerManager.Image.ImageTag = constants.KubeDefaultVersion
+	}
+	if kubeControllerManager.Replicas == nil {
+		kubeControllerManager.Replicas = pointer.Int32(1)
+	}
+}
+
+func setDefaultsKarmadaControllerManager(obj *KarmadaComponents) {
+	if obj.KarmadaControllerManager == nil {
+		obj.KarmadaControllerManager = &KarmadaControllerManager{}
+	}
+
+	karmadaControllerManager := obj.KarmadaControllerManager
+	if len(karmadaControllerManager.Image.ImageRepository) == 0 {
+		karmadaControllerManager.Image.ImageRepository = karmadaControllerManagerImageRepository
+	}
+	if len(karmadaControllerManager.Image.ImageTag) == 0 {
+		karmadaControllerManager.Image.ImageTag = constants.KarmadaDefaultVersion
+	}
+	if karmadaControllerManager.Replicas == nil {
+		karmadaControllerManager.Replicas = pointer.Int32(1)
+	}
+}
+
+func setDefaultsKarmadaScheduler(obj *KarmadaComponents) {
+	if obj.KarmadaScheduler == nil {
+		obj.KarmadaScheduler = &KarmadaScheduler{}
+	}
+
+	scheduler := obj.KarmadaScheduler
+	if len(scheduler.Image.ImageRepository) == 0 {
+		scheduler.Image.ImageRepository = karmadaSchedulerImageRepository
+	}
+	if len(scheduler.Image.ImageTag) == 0 {
+		scheduler.Image.ImageTag = constants.KarmadaDefaultVersion
+	}
+	if scheduler.Replicas == nil {
+		scheduler.Replicas = pointer.Int32(1)
+	}
+}
+
+func setDefaultsKarmadaWebhook(obj *KarmadaComponents) {
+	if obj.KarmadaWebhook == nil {
+		obj.KarmadaWebhook = &KarmadaWebhook{}
+	}
+
+	webhook := obj.KarmadaWebhook
+	if len(webhook.Image.ImageRepository) == 0 {
+		webhook.Image.ImageRepository = karmadaWebhookImageRepository
+	}
+	if len(webhook.Image.ImageTag) == 0 {
+		webhook.Image.ImageTag = constants.KarmadaDefaultVersion
+	}
+	if webhook.Replicas == nil {
+		webhook.Replicas = pointer.Int32(1)
+	}
+}

operator/pkg/apis/operator/v1alpha1/doc.go

@@ -1,4 +1,5 @@
 // +k8s:deepcopy-gen=package
+// +k8s:defaulter-gen=ObjectMeta
 // +groupName=operator.karmada.io
 
 package v1alpha1

operator/pkg/apis/operator/v1alpha1/register.go

@@ -1,5 +1,3 @@
-// Code generated by register-gen. DO NOT EDIT.
-
 package v1alpha1
 
 import (
@@ -24,19 +22,19 @@ func Resource(resource string) schema.GroupResource {
 }
 
 var (
-	// localSchemeBuilder and AddToScheme will stay in k8s.io/kubernetes.
+	// SchemeBuilder will stay in k8s.io/kubernetes.
 	SchemeBuilder runtime.SchemeBuilder
+	// localSchemeBuilder will stay in k8s.io/kubernetes.
 	localSchemeBuilder = &SchemeBuilder
-	// Depreciated: use Install instead
+	// AddToScheme applies all the stored functions to the scheme
 	AddToScheme = localSchemeBuilder.AddToScheme
-	Install     = localSchemeBuilder.AddToScheme
 )
 
 func init() {
 	// We only register manually written functions here. The registration of the
 	// generated functions takes place in the generated files. The separation
 	// makes the code compile even when the generated files are missing.
-	localSchemeBuilder.Register(addKnownTypes)
+	localSchemeBuilder.Register(addKnownTypes, addDefaultingFuncs)
 }
 
 // Adds the list of known types to Scheme.

operator/pkg/constants/constants.go

@@ -17,6 +17,10 @@ const (
 	KarmadaDefaultVersion = "v1.4.0"
 	// KubeDefaultVersion defines the default of the karmada apiserver and kubeControllerManager image tag
 	KubeDefaultVersion = "v1.25.2"
+	// KarmadaDefaultServiceSubnet defines the default of the subnet used by k8s services.
+	KarmadaDefaultServiceSubnet = "10.96.0.0/12"
+	// KarmadaDefaultDNSDomain defines the default of the DNSDomain
+	KarmadaDefaultDNSDomain = "cluster.local"
 
 	// KarmadaOperator defines the name of the karmada operator.
 	KarmadaOperator = "karmada-operator"

operator/pkg/controller/karmada/controller.go

@@ -2,6 +2,7 @@ package karmada
 
 import (
 	"context"
+	"reflect"
 	"time"
 
 	"k8s.io/apimachinery/pkg/api/errors"
@@ -13,6 +14,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
 
 	operatorv1alpha1 "github.com/karmada-io/karmada/operator/pkg/apis/operator/v1alpha1"
+	operatorscheme "github.com/karmada-io/karmada/operator/pkg/scheme"
 )
 
 const (
@@ -52,16 +54,10 @@ func (ctrl *Controller) Reconcile(ctx context.Context, req controllerruntime.Req
 
 	// examine DeletionTimestamp to determine if object is under deletion
 	if karmada.DeletionTimestamp.IsZero() {
-		// The object is not being deleted, so if it does not have our finalizer,
-		// then lets add the finalizer and update the object. This is equivalent
-		// registering our finalizer.
-		if !controllerutil.ContainsFinalizer(karmada, ControllerFinalizerName) {
-			controllerutil.AddFinalizer(karmada, ControllerFinalizerName)
-			if err := ctrl.Update(ctx, karmada); err != nil {
+		if err := ctrl.ensureKarmada(ctx, karmada); err != nil {
 			return controllerruntime.Result{}, err
 		}
 	}
-	}
 
 	klog.V(2).InfoS("Reconciling karmada", "name", req.Name)
 	planner, err := NewPlannerFor(karmada, ctrl.Client, ctrl.Config)
@@ -92,6 +88,25 @@ func (ctrl *Controller) removeFinalizer(ctx context.Context, karmada *operatorv1
 	return controllerruntime.Result{}, nil
 }
 
+func (ctrl *Controller) ensureKarmada(ctx context.Context, karmada *operatorv1alpha1.Karmada) error {
+	// The object is not being deleted, so if it does not have our finalizer,
+	// then lets add the finalizer and update the object. This is equivalent
+	// registering our finalizer.
+	updated := controllerutil.AddFinalizer(karmada, ControllerFinalizerName)
+	older := karmada.DeepCopy()
+
+	// Set the defaults for karmada
+	operatorscheme.Scheme.Default(karmada)
+
+	if updated || !reflect.DeepEqual(karmada.Spec, older.Spec) {
+		if err := ctrl.Update(ctx, karmada); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 // SetupWithManager creates a controller and register to controller manager.
 func (ctrl *Controller) SetupWithManager(mgr controllerruntime.Manager) error {
 	return controllerruntime.NewControllerManagedBy(mgr).For(&operatorv1alpha1.Karmada{}).Complete(ctrl)

operator/pkg/init.go

@@ -6,16 +6,15 @@ import (
 	"net/url"
 	"sync"
 
-	corev1 "k8s.io/api/core/v1"
 	utilversion "k8s.io/apimachinery/pkg/util/version"
 	clientset "k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 	"k8s.io/klog/v2"
-	"k8s.io/utils/pointer"
 
 	operatorv1alpha1 "github.com/karmada-io/karmada/operator/pkg/apis/operator/v1alpha1"
 	"github.com/karmada-io/karmada/operator/pkg/certs"
 	"github.com/karmada-io/karmada/operator/pkg/constants"
+	operatorscheme "github.com/karmada-io/karmada/operator/pkg/scheme"
 	tasks "github.com/karmada-io/karmada/operator/pkg/tasks/init"
 	workflow "github.com/karmada-io/karmada/operator/pkg/workflow"
 )
@@ -32,10 +31,7 @@ type InitOptions struct {
 	KarmadaVersion string
 	CrdRemoteURL   string
 	KarmadaDataDir string
-	PrivateRegistry string
-	HostCluster     *operatorv1alpha1.HostCluster
-	Components      *operatorv1alpha1.KarmadaComponents
-	FeatureGates    map[string]bool
+	Karmada        *operatorv1alpha1.Karmada
 }
 
 // InitOpt defines a type of function to set InitOptions values.
@@ -81,10 +77,17 @@ func NewInitJob(opt *InitOptions) *workflow.Job {
 	initJob.AppendTask(tasks.NewWaitControlPlaneTask())
 
 	initJob.SetDataInitializer(func() (workflow.RunData, error) {
+		return newRunData(opt)
+	})
+
+	return initJob
+}
+
+func newRunData(opt *InitOptions) (*initData, error) {
 	// if there is no endpoint info, we are consider that the local cluster
 	// is remote cluster to install karmada.
 	var remoteClient clientset.Interface
-		if opt.HostCluster.SecretRef == nil && len(opt.HostCluster.APIEndpoint) == 0 {
+	if opt.Karmada.Spec.HostCluster.SecretRef == nil && len(opt.Karmada.Spec.HostCluster.APIEndpoint) == 0 {
 		client, err := clientset.NewForConfig(opt.Kubeconfig)
 		if err != nil {
 			return nil, fmt.Errorf("error when create cluster client to install karmada, err: %w", err)
@@ -93,6 +96,11 @@ func NewInitJob(opt *InitOptions) *workflow.Job {
 		remoteClient = client
 	}
 
+	var privateRegistry string
+	if opt.Karmada.Spec.PrivateRegistry != nil {
+		privateRegistry = opt.Karmada.Spec.PrivateRegistry.Registry
+	}
+
 	if len(opt.Name) == 0 || len(opt.Namespace) == 0 {
 		return nil, errors.New("unexpected empty name or namespace")
 	}
@@ -108,8 +116,9 @@ func NewInitJob(opt *InitOptions) *workflow.Job {
 		}
 	}
 
-		if opt.Components.Etcd.Local != nil && opt.Components.Etcd.Local.CommonSettings.Replicas != nil {
-			replicas := *opt.Components.Etcd.Local.CommonSettings.Replicas
+	if opt.Karmada.Spec.Components.Etcd.Local != nil && opt.Karmada.Spec.Components.Etcd.Local.CommonSettings.Replicas != nil {
+		replicas := *opt.Karmada.Spec.Components.Etcd.Local.CommonSettings.Replicas
+
 		if (replicas % 2) == 0 {
 			klog.Warningf("invalid etcd replicas %d, expected an odd number", replicas)
 		}
@@ -124,15 +133,12 @@ func NewInitJob(opt *InitOptions) *workflow.Job {
 		remoteClient:    remoteClient,
 		crdRemoteURL:    opt.CrdRemoteURL,
 		karmadaDataDir:  opt.KarmadaDataDir,
-			privateRegistry: opt.PrivateRegistry,
-			components:      opt.Components,
-			featureGates:    opt.FeatureGates,
-			dnsDomain:       *opt.HostCluster.Networking.DNSDomain,
+		privateRegistry: privateRegistry,
+		components:      opt.Karmada.Spec.Components,
+		featureGates:    opt.Karmada.Spec.FeatureGates,
+		dnsDomain:       *opt.Karmada.Spec.HostCluster.Networking.DNSDomain,
 		CertStore:       certs.NewCertStore(),
 	}, nil
-	})
-
-	return initJob
 }
 
 func (data *initData) GetName() string {
@@ -197,120 +203,25 @@ func NewJobInitOptions(opts ...InitOpt) *InitOptions {
 }
 
 func defaultJobInitOptions() *InitOptions {
+	karmada := &operatorv1alpha1.Karmada{}
+
+	// set defaults for karmada.
+	operatorscheme.Scheme.Default(karmada)
+
 	return &InitOptions{
 		CrdRemoteURL:   fmt.Sprintf(defaultCrdURL, constants.KarmadaDefaultVersion),
-		Name:           "karmada",
-		Namespace:      constants.KarmadaSystemNamespace,
 		KarmadaVersion: constants.KarmadaDefaultVersion,
 		KarmadaDataDir: constants.KarmadaDataDir,
-		Components:     defaultComponents(),
-		HostCluster:    defaultHostCluster(),
-	}
-}
-
-func defaultHostCluster() *operatorv1alpha1.HostCluster {
-	return &operatorv1alpha1.HostCluster{
-		Networking: &operatorv1alpha1.Networking{
-			DNSDomain: pointer.String("cluster.local"),
-		},
-	}
-}
-
-func defaultComponents() *operatorv1alpha1.KarmadaComponents {
-	return &operatorv1alpha1.KarmadaComponents{
-		Etcd: &operatorv1alpha1.Etcd{
-			Local: &operatorv1alpha1.LocalEtcd{
-				CommonSettings: operatorv1alpha1.CommonSettings{
-					Image: operatorv1alpha1.Image{
-						ImageRepository: fmt.Sprintf("%s/%s", constants.KubeDefaultRepository, constants.Etcd),
-						ImageTag:        constants.EtcdDefaultVersion,
-					},
-					Replicas: pointer.Int32(1),
-				},
-
-				VolumeData: &operatorv1alpha1.VolumeData{
-					EmptyDir: &corev1.EmptyDirVolumeSource{},
-				},
-			},
-		},
-
-		KarmadaAPIServer: &operatorv1alpha1.KarmadaAPIServer{
-			CommonSettings: operatorv1alpha1.CommonSettings{
-				Replicas: pointer.Int32(1),
-				Image: operatorv1alpha1.Image{
-					ImageRepository: fmt.Sprintf("%s/%s", constants.KubeDefaultRepository, constants.KarmadaAPIServer),
-					ImageTag:        constants.KubeDefaultVersion,
-				},
-			},
-			ServiceSubnet: pointer.String("10.96.0.0/12"),
-			ServiceType:   corev1.ServiceTypeClusterIP,
-		},
-		KarmadaAggregratedAPIServer: &operatorv1alpha1.KarmadaAggregratedAPIServer{
-			CommonSettings: operatorv1alpha1.CommonSettings{
-				Replicas: pointer.Int32(1),
-				Image: operatorv1alpha1.Image{
-					ImageRepository: fmt.Sprintf("%s/%s", constants.KarmadaDefaultRepository, constants.KarmadaAggregatedAPIServer),
-					ImageTag:        constants.KarmadaDefaultVersion,
-				},
-			},
-		},
-		KubeControllerManager: &operatorv1alpha1.KubeControllerManager{
-			CommonSettings: operatorv1alpha1.CommonSettings{
-				Replicas: pointer.Int32(1),
-				Image: operatorv1alpha1.Image{
-					ImageRepository: fmt.Sprintf("%s/%s", constants.KubeDefaultRepository, constants.KubeControllerManager),
-					ImageTag:        constants.KubeDefaultVersion,
-				},
-			},
-		},
-		KarmadaControllerManager: &operatorv1alpha1.KarmadaControllerManager{
-			CommonSettings: operatorv1alpha1.CommonSettings{
-				Replicas: pointer.Int32(1),
-				Image: operatorv1alpha1.Image{
-					ImageRepository: fmt.Sprintf("%s/%s", constants.KarmadaDefaultRepository, constants.KarmadaControllerManager),
-					ImageTag:        constants.KarmadaDefaultVersion,
-				},
-			},
-		},
-		KarmadaScheduler: &operatorv1alpha1.KarmadaScheduler{
-			CommonSettings: operatorv1alpha1.CommonSettings{
-				Replicas: pointer.Int32(1),
-				Image: operatorv1alpha1.Image{
-					ImageRepository: fmt.Sprintf("%s/%s", constants.KarmadaDefaultRepository, constants.KarmadaScheduler),
-					ImageTag:        constants.KarmadaDefaultVersion,
-				},
-			},
-		},
-		KarmadaWebhook: &operatorv1alpha1.KarmadaWebhook{
-			CommonSettings: operatorv1alpha1.CommonSettings{
-				Replicas: pointer.Int32(1),
-				Image: operatorv1alpha1.Image{
-					ImageRepository: fmt.Sprintf("%s/%s", constants.KarmadaDefaultRepository, constants.KarmadaWebhook),
-					ImageTag:        constants.KarmadaDefaultVersion,
-				},
-			},
-		},
+		Karmada:        karmada,
 	}
 }
 
 // NewInitOptWithKarmada returns a InitOpt function to initialize InitOptions with karmada resource
 func NewInitOptWithKarmada(karmada *operatorv1alpha1.Karmada) InitOpt {
 	return func(opt *InitOptions) {
+		opt.Karmada = karmada
 		opt.Name = karmada.GetName()
 		opt.Namespace = karmada.GetNamespace()
-		opt.FeatureGates = karmada.Spec.FeatureGates
-
-		if karmada.Spec.PrivateRegistry != nil && len(karmada.Spec.PrivateRegistry.Registry) > 0 {
-			opt.PrivateRegistry = karmada.Spec.PrivateRegistry.Registry
-		}
-
-		if karmada.Spec.Components != nil {
-			opt.Components = karmada.Spec.Components
-		}
-
-		if karmada.Spec.HostCluster != nil {
-			opt.HostCluster = karmada.Spec.HostCluster
-		}
 	}
 }
 

operator/pkg/karmadaresource/apiservice/apiservice.go

@@ -6,7 +6,6 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
-	kuberuntime "k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
@@ -51,7 +50,7 @@ func aggregatedAPIService(client *aggregator.Clientset, name, namespace string)
 	}
 
 	apiService := &apiregistrationv1.APIService{}
-	if err := kuberuntime.DecodeInto(codecs.UniversalDecoder(), apiServiceBytes, apiService); err != nil {
+	if err := runtime.DecodeInto(codecs.UniversalDecoder(), apiServiceBytes, apiService); err != nil {
 		return fmt.Errorf("err when decoding AggregatedApiserver APIService: %w", err)
 	}
 
@@ -74,7 +73,7 @@ func aggregatedApiserverService(client clientset.Interface, name, namespace stri
 	}
 
 	aggregatedService := &corev1.Service{}
-	if err := kuberuntime.DecodeInto(clientsetscheme.Codecs.UniversalDecoder(), aggregatedApiserverServiceBytes, aggregatedService); err != nil {
+	if err := runtime.DecodeInto(clientsetscheme.Codecs.UniversalDecoder(), aggregatedApiserverServiceBytes, aggregatedService); err != nil {
 		return fmt.Errorf("err when decoding AggregatedApiserver Service: %w", err)
 	}