Merge pull request #3493 from calvin0327/support-custom-labels-and-annotation

karmada operator: support custom labels and  annotations

operator/pkg/controlplane/apiserver/apiserver.go

@@ -13,6 +13,7 @@ import (
 	"github.com/karmada-io/karmada/operator/pkg/constants"
 	"github.com/karmada-io/karmada/operator/pkg/util"
 	"github.com/karmada-io/karmada/operator/pkg/util/apiclient"
+	"github.com/karmada-io/karmada/operator/pkg/util/patcher"
 )
 
 // EnsureKarmadaAPIServer creates karmada apiserver deployment and service resource
@@ -58,6 +59,8 @@ func installKarmadaAPIServer(client clientset.Interface, cfg *operatorv1alpha1.K
 		return fmt.Errorf("error when decoding karmadaApiserver deployment: %w", err)
 	}
 
+	patcher.NewPatcher().WithAnnotations(cfg.Annotations).WithLabels(cfg.Labels).ForDeployment(apiserverDeployment)
+
 	if err := apiclient.CreateOrUpdateDeployment(client, apiserverDeployment); err != nil {
 		return fmt.Errorf("error when creating deployment for %s, err: %w", apiserverDeployment.Name, err)
 	}
@@ -113,6 +116,8 @@ func installKarmadaAggregatedAPIServer(client clientset.Interface, cfg *operator
 		return fmt.Errorf("err when decoding karmadaApiserver deployment: %w", err)
 	}
 
+	patcher.NewPatcher().WithAnnotations(cfg.Annotations).WithLabels(cfg.Labels).ForDeployment(aggregatedAPIServerDeployment)
+
 	if err := apiclient.CreateOrUpdateDeployment(client, aggregatedAPIServerDeployment); err != nil {
 		return fmt.Errorf("error when creating deployment for %s, err: %w", aggregatedAPIServerDeployment.Name, err)
 	}

operator/pkg/controlplane/controlplane.go

@@ -12,13 +12,11 @@ import (
 	"github.com/karmada-io/karmada/operator/pkg/constants"
 	"github.com/karmada-io/karmada/operator/pkg/util"
 	"github.com/karmada-io/karmada/operator/pkg/util/apiclient"
+	"github.com/karmada-io/karmada/operator/pkg/util/patcher"
 )
 
-// PatchManifest defines a function to patch deployment
-type PatchManifest func(cfg *operatorv1alpha1.KarmadaComponents, deployment *appsv1.Deployment)
-
 // EnsureControlPlaneComponent creates karmada controllerManager, kubeControllerManager, scheduler, webhook component
-func EnsureControlPlaneComponent(component, name, namespace string, client clientset.Interface, cfg *operatorv1alpha1.KarmadaComponents, patchManifestFunc PatchManifest) error {
+func EnsureControlPlaneComponent(component, name, namespace string, client clientset.Interface, cfg *operatorv1alpha1.KarmadaComponents) error {
 	deployments, err := getComponentManifests(name, namespace, cfg)
 	if err != nil {
 		return err
@@ -28,11 +26,6 @@ func EnsureControlPlaneComponent(component, name, namespace string, client clien
 	if !ok {
 		return fmt.Errorf("no exist manifest for %s", component)
 	}
-
-	if patchManifestFunc != nil {
-		patchManifestFunc(cfg, deployment)
-	}
-
 	if err := apiclient.CreateOrUpdateDeployment(client, deployment); err != nil {
 		return fmt.Errorf("failed to create deployment resource for component %s, err: %w", component, err)
 	}
@@ -44,11 +37,11 @@ func getComponentManifests(name, namespace string, cfg *operatorv1alpha1.Karmada
 	if err != nil {
 		return nil, err
 	}
-	karmadaControllerManager, err := karmadaControllerManagerManifest(name, namespace, cfg.KarmadaControllerManager)
+	karmadaControllerManager, err := getKarmadaControllerManagerManifest(name, namespace, cfg.KarmadaControllerManager)
 	if err != nil {
 		return nil, err
 	}
-	scheduler, err := karmadaSchedulerManifest(name, namespace, cfg.KarmadaScheduler)
+	scheduler, err := getKarmadaSchedulerManifest(name, namespace, cfg.KarmadaScheduler)
 	if err != nil {
 		return nil, err
 	}
@@ -82,10 +75,11 @@ func getKubeControllerManagerManifest(name, namespace string, cfg *operatorv1alp
 		return nil, fmt.Errorf("err when decoding KubeControllerManager Deployment: %w", err)
 	}
 
+	patcher.NewPatcher().WithAnnotations(cfg.Annotations).WithLabels(cfg.Labels).ForDeployment(kcm)
 	return kcm, nil
 }
 
-func karmadaControllerManagerManifest(name, namespace string, cfg *operatorv1alpha1.KarmadaControllerManager) (*appsv1.Deployment, error) {
+func getKarmadaControllerManagerManifest(name, namespace string, cfg *operatorv1alpha1.KarmadaControllerManager) (*appsv1.Deployment, error) {
 	karmadaControllerManageretBytes, err := util.ParseTemplate(KamradaControllerManagerDeployment, struct {
 		Replicas                  *int32
 		DeploymentName, Namespace string
@@ -106,10 +100,11 @@ func karmadaControllerManagerManifest(name, namespace string, cfg *operatorv1alp
 		return nil, fmt.Errorf("err when decoding KarmadaControllerManager Deployment: %w", err)
 	}
 
+	patcher.NewPatcher().WithAnnotations(cfg.Annotations).WithLabels(cfg.Labels).ForDeployment(kcm)
 	return kcm, nil
 }
 
-func karmadaSchedulerManifest(name, namespace string, cfg *operatorv1alpha1.KarmadaScheduler) (*appsv1.Deployment, error) {
+func getKarmadaSchedulerManifest(name, namespace string, cfg *operatorv1alpha1.KarmadaScheduler) (*appsv1.Deployment, error) {
 	karmadaSchedulerBytes, err := util.ParseTemplate(KarmadaSchedulerDeployment, struct {
 		Replicas                  *int32
 		DeploymentName, Namespace string
@@ -130,5 +125,6 @@ func karmadaSchedulerManifest(name, namespace string, cfg *operatorv1alpha1.Karm
 		return nil, fmt.Errorf("err when decoding KarmadaScheduler Deployment: %w", err)
 	}
 
+	patcher.NewPatcher().WithAnnotations(cfg.Annotations).WithLabels(cfg.Labels).ForDeployment(scheduler)
 	return scheduler, nil
 }

operator/pkg/controlplane/etcd/etcd.go

@@ -14,6 +14,7 @@ import (
 	"github.com/karmada-io/karmada/operator/pkg/constants"
 	"github.com/karmada-io/karmada/operator/pkg/util"
 	"github.com/karmada-io/karmada/operator/pkg/util/apiclient"
+	"github.com/karmada-io/karmada/operator/pkg/util/patcher"
 )
 
 // EnsureKarmadaEtcd creates etcd StatefulSet and service resource.
@@ -69,6 +70,8 @@ func installKarmadaEtcd(client clientset.Interface, name, namespace string, cfg
 		return fmt.Errorf("error when decoding Etcd StatefulSet: %w", err)
 	}
 
+	patcher.NewPatcher().WithAnnotations(cfg.Annotations).WithLabels(cfg.Labels).ForStatefulSet(etcdStatefulSet)
+
 	if err := apiclient.CreateOrUpdateStatefulSet(client, etcdStatefulSet); err != nil {
 		return fmt.Errorf("error when creating Etcd statefulset, err: %w", err)
 	}

operator/pkg/controlplane/webhook/webhook.go

@@ -12,6 +12,7 @@ import (
 	operatorv1alpha1 "github.com/karmada-io/karmada/operator/pkg/apis/operator/v1alpha1"
 	"github.com/karmada-io/karmada/operator/pkg/util"
 	"github.com/karmada-io/karmada/operator/pkg/util/apiclient"
+	"github.com/karmada-io/karmada/operator/pkg/util/patcher"
 )
 
 // EnsureKarmadaWebhook creates karmada webhook deployment and service resource.
@@ -45,6 +46,8 @@ func installKarmadaWebhook(client clientset.Interface, cfg *operatorv1alpha1.Kar
 		return fmt.Errorf("err when decoding KarmadaWebhook Deployment: %w", err)
 	}
 
+	patcher.NewPatcher().WithAnnotations(cfg.Annotations).WithLabels(cfg.Labels).ForDeployment(webhookDeployment)
+
 	if err := apiclient.CreateOrUpdateDeployment(client, webhookDeployment); err != nil {
 		return fmt.Errorf("error when creating deployment for %s, err: %w", webhookDeployment.Name, err)
 	}

operator/pkg/tasks/init/component.go

@@ -19,9 +19,9 @@ func NewComponentTask() workflow.Task {
 		Run:         runComponents,
 		RunSubTasks: true,
 		Tasks: []workflow.Task{
-			newComponentSubTask(constants.KubeControllerManagerComponent, nil),
+			newComponentSubTask(constants.KubeControllerManagerComponent),
-			newComponentSubTask(constants.KarmadaControllerManagerComponent, nil),
+			newComponentSubTask(constants.KarmadaControllerManagerComponent),
-			newComponentSubTask(constants.KarmadaSchedulerComponent, nil),
+			newComponentSubTask(constants.KarmadaSchedulerComponent),
 			{
 				Name: "KarmadaWebhook",
 				Run:  runKarmadaWebhook,
@@ -40,14 +40,14 @@ func runComponents(r workflow.RunData) error {
 	return nil
 }
 
-func newComponentSubTask(component string, patchManifestFunc controlplane.PatchManifest) workflow.Task {
+func newComponentSubTask(component string) workflow.Task {
 	return workflow.Task{
 		Name: component,
-		Run:  runComponentSubTask(component, patchManifestFunc),
+		Run:  runComponentSubTask(component),
 	}
 }
 
-func runComponentSubTask(component string, patchManifestFunc controlplane.PatchManifest) func(r workflow.RunData) error {
+func runComponentSubTask(component string) func(r workflow.RunData) error {
 	return func(r workflow.RunData) error {
 		data, ok := r.(InitData)
 		if !ok {
@@ -60,7 +60,6 @@ func runComponentSubTask(component string, patchManifestFunc controlplane.PatchM
 			data.GetNamespace(),
 			data.RemoteClient(),
 			data.Components(),
-			patchManifestFunc,
 		)
 		if err != nil {
 			return fmt.Errorf("failed to apply component %s, err: %w", component, err)

operator/pkg/util/patcher/pather.go

@@ -0,0 +1,47 @@
+package patcher
+
+import (
+	appsv1 "k8s.io/api/apps/v1"
+	"k8s.io/apimachinery/pkg/labels"
+)
+
+// Patcher defines multiple variables that need to be patched.
+type Patcher struct {
+	labels      map[string]string
+	annotations map[string]string
+}
+
+// NewPatcher returns a patcher.
+func NewPatcher() *Patcher {
+	return &Patcher{}
+}
+
+// WithLabels sets labels to the patcher.
+func (p *Patcher) WithLabels(labels labels.Set) *Patcher {
+	p.labels = labels
+	return p
+}
+
+// WithAnnotations sets annotations to the patcher.
+func (p *Patcher) WithAnnotations(annotations labels.Set) *Patcher {
+	p.annotations = annotations
+	return p
+}
+
+// ForDeployment patches the deployment manifest.
+func (p *Patcher) ForDeployment(deployment *appsv1.Deployment) {
+	deployment.Labels = labels.Merge(deployment.Labels, p.labels)
+	deployment.Spec.Template.Labels = labels.Merge(deployment.Spec.Template.Labels, p.labels)
+
+	deployment.Annotations = labels.Merge(deployment.Annotations, p.annotations)
+	deployment.Spec.Template.Annotations = labels.Merge(deployment.Spec.Template.Annotations, p.annotations)
+}
+
+// ForStatefulSet patches the statefulset manifest.
+func (p *Patcher) ForStatefulSet(sts *appsv1.StatefulSet) {
+	sts.Labels = labels.Merge(sts.Labels, p.labels)
+	sts.Spec.Template.Labels = labels.Merge(sts.Spec.Template.Labels, p.labels)
+
+	sts.Annotations = labels.Merge(sts.Annotations, p.annotations)
+	sts.Spec.Template.Annotations = labels.Merge(sts.Spec.Template.Annotations, p.annotations)
+}