optimize karmada aggregated apiserver startup

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

operator/pkg/init.go

@@ -75,7 +75,7 @@ func NewInitJob(opt *InitOptions) *workflow.Job {
 	initJob.AppendTask(tasks.NewUploadCertsTask())
 	initJob.AppendTask(tasks.NewEtcdTask())
 	initJob.AppendTask(tasks.NewKarmadaApiserverTask())
-	initJob.AppendTask(tasks.NewWaitApiserverTask())
+	initJob.AppendTask(tasks.NewCheckApiserverHealthTask())
 	initJob.AppendTask(tasks.NewKarmadaResourcesTask())
 	initJob.AppendTask(tasks.NewComponentTask())
 	initJob.AppendTask(tasks.NewWaitControlPlaneTask())

operator/pkg/tasks/init/apiserver.go

@@ -3,11 +3,13 @@ package tasks
 import (
 	"errors"
 	"fmt"
+	"time"
 
 	"k8s.io/klog/v2"
 
 	"github.com/karmada-io/karmada/operator/pkg/constants"
 	"github.com/karmada-io/karmada/operator/pkg/controlplane/apiserver"
+	"github.com/karmada-io/karmada/operator/pkg/util/apiclient"
 	"github.com/karmada-io/karmada/operator/pkg/workflow"
 )
 
@@ -23,10 +25,18 @@ func NewKarmadaApiserverTask() workflow.Task {
 				Name: constants.KarmadaAPIserverComponent,
 				Run:  runKarmadaAPIServer,
 			},
+			{
+				Name: fmt.Sprintf("%s-%s", "wait", constants.KarmadaAPIserverComponent),
+				Run:  runWaitKarmadaAPIServer,
+			},
 			{
 				Name: constants.KarmadaAggregratedAPIServerComponent,
 				Run:  runKarmadaAggregratedAPIServer,
 			},
+			{
+				Name: fmt.Sprintf("%s-%s", "wait", constants.KarmadaAggregratedAPIServerComponent),
+				Run:  runWaitKarmadaAggregratedAPIServer,
+			},
 		},
 	}
 }
@@ -44,12 +54,12 @@ func runApiserver(r workflow.RunData) error {
 func runKarmadaAPIServer(r workflow.RunData) error {
 	data, ok := r.(InitData)
 	if !ok {
-		return errors.New("karmadaApiserver task invoked with an invalid data struct")
+		return errors.New("KarmadaApiserver task invoked with an invalid data struct")
 	}
 
 	cfg := data.Components()
 	if cfg.KarmadaAPIServer == nil {
-		klog.V(2).InfoS("[karmadaApiserver] Skip install karmada-apiserver component")
+		klog.V(2).InfoS("[KarmadaApiserver] Skip install karmada-apiserver component")
 		return nil
 	}
 
@@ -58,19 +68,36 @@ func runKarmadaAPIServer(r workflow.RunData) error {
 		return fmt.Errorf("failed to install karmada apiserver component, err: %w", err)
 	}
 
-	klog.V(2).InfoS("[karmadaApiserver] Successfully installed apiserver component", "karmada", klog.KObj(data))
+	klog.V(2).InfoS("[KarmadaApiserver] Successfully installed karmada-apiserver component", "karmada", klog.KObj(data))
+	return nil
+}
+
+func runWaitKarmadaAPIServer(r workflow.RunData) error {
+	data, ok := r.(InitData)
+	if !ok {
+		return errors.New("wait-KarmadaAPIServer task invoked with an invalid data struct")
+	}
+
+	waiter := apiclient.NewKarmadaWaiter(data.ControlplaneConifg(), data.RemoteClient(), time.Second*30)
+
+	err := waiter.WaitForSomePods(karmadaApiserverLabels.String(), data.GetNamespace(), 1)
+	if err != nil {
+		return fmt.Errorf("waiting for karmada-apiserver to ready timeout, err: %w", err)
+	}
+
+	klog.V(2).InfoS("[wait-KarmadaAPIServer] the karmada-apiserver is ready", "karmada", klog.KObj(data))
 	return nil
 }
 
 func runKarmadaAggregratedAPIServer(r workflow.RunData) error {
 	data, ok := r.(InitData)
 	if !ok {
-		return errors.New("karmadaAggregratedApiServer task invoked with an invalid data struct")
+		return errors.New("KarmadaAggregratedAPIServer task invoked with an invalid data struct")
 	}
 
 	cfg := data.Components()
 	if cfg.KarmadaAggregratedAPIServer == nil {
-		klog.V(2).InfoS("[KarmadaAggregratedApiServer] Skip install karmada-aggregrated-apiserver component")
+		klog.V(2).InfoS("[KarmadaAggregratedAPIServer] Skip install karmada-aggregrated-apiserver component")
 		return nil
 	}
 
@@ -79,6 +106,23 @@ func runKarmadaAggregratedAPIServer(r workflow.RunData) error {
 		return fmt.Errorf("failed to install karmada aggregrated apiserver, err: %w", err)
 	}
 
-	klog.V(2).InfoS("[KarmadaAggregratedApiServer] Successfully installed karmada apiserve component", "karmada", klog.KObj(data))
+	klog.V(2).InfoS("[KarmadaAggregratedApiserve] Successfully installed karmada-aggregrated-apiserver component", "karmada", klog.KObj(data))
+	return nil
+}
+
+func runWaitKarmadaAggregratedAPIServer(r workflow.RunData) error {
+	data, ok := r.(InitData)
+	if !ok {
+		return errors.New("wait-KarmadaAggregratedAPIServer task invoked with an invalid data struct")
+	}
+
+	waiter := apiclient.NewKarmadaWaiter(data.ControlplaneConifg(), data.RemoteClient(), time.Second*30)
+
+	err := waiter.WaitForSomePods(karmadaAggregatedAPIServerLabels.String(), data.GetNamespace(), 1)
+	if err != nil {
+		return fmt.Errorf("waiting for karmada-apiserver to ready timeout, err: %w", err)
+	}
+
+	klog.V(2).InfoS("[wait-KarmadaAggregratedAPIServer] the karmada-aggregated-apiserver is ready", "karmada", klog.KObj(data))
 	return nil
 }

operator/pkg/tasks/init/etcd.go

@@ -3,18 +3,31 @@ package tasks
 import (
 	"errors"
 	"fmt"
+	"time"
 
 	"k8s.io/klog/v2"
 
 	"github.com/karmada-io/karmada/operator/pkg/controlplane/etcd"
+	"github.com/karmada-io/karmada/operator/pkg/util/apiclient"
 	"github.com/karmada-io/karmada/operator/pkg/workflow"
 )
 
 // NewEtcdTask init a etcd task to install etcd component
 func NewEtcdTask() workflow.Task {
 	return workflow.Task{
-		Name: "Etcd",
+		Name:        "Etcd",
-		Run:  runEtcd,
+		Run:         runEtcd,
+		RunSubTasks: true,
+		Tasks: []workflow.Task{
+			{
+				Name: "deploy-etcd",
+				Run:  runDeployEtcd,
+			},
+			{
+				Name: "wait-etcd",
+				Run:  runWaitEtcd,
+			},
+		},
 	}
 }
 
@@ -23,7 +36,16 @@ func runEtcd(r workflow.RunData) error {
 	if !ok {
 		return errors.New("etcd task invoked with an invalid data struct")
 	}
+
 	klog.V(4).InfoS("[etcd] Running etcd task", "karmada", klog.KObj(data))
+	return nil
+}
+
+func runDeployEtcd(r workflow.RunData) error {
+	data, ok := r.(InitData)
+	if !ok {
+		return errors.New("deploy-etcd task invoked with an invalid data struct")
+	}
 
 	cfg := data.Components()
 	if cfg.Etcd.External != nil {
@@ -40,6 +62,24 @@ func runEtcd(r workflow.RunData) error {
 		return fmt.Errorf("failed to install etcd component, err: %w", err)
 	}
 
-	klog.V(2).InfoS("[etcd] Successfully installed etcd component", "karmada", klog.KObj(data))
+	klog.V(2).InfoS("[deploy-etcd] Successfully installed etcd component", "karmada", klog.KObj(data))
+	return nil
+}
+
+func runWaitEtcd(r workflow.RunData) error {
+	data, ok := r.(InitData)
+	if !ok {
+		return errors.New("wait-etcd task invoked with an invalid data struct")
+	}
+
+	waiter := apiclient.NewKarmadaWaiter(data.ControlplaneConifg(), data.RemoteClient(), time.Second*30)
+
+	// wait etcd, karmada apiserver and aggregated apiserver to ready
+	// as long as a replica of pod is ready, we consider the service available.
+	if err := waiter.WaitForSomePods(etcdLabels.String(), data.GetNamespace(), 1); err != nil {
+		return fmt.Errorf("waiting for etcd to ready timeout, err: %w", err)
+	}
+
+	klog.V(2).InfoS("[wait-etcd] the etcd pods is ready", "karmada", klog.KObj(data))
 	return nil
 }

operator/pkg/tasks/init/wait.go

@@ -23,10 +23,10 @@ var (
 	karmadaWebhookLabels             = labels.Set{"karmada-app": constants.KarmadaWebhook}
 )
 
-// NewWaitApiserverTask init wait-apiserver task
+// NewCheckApiserverHealthTask init wait-apiserver task
-func NewWaitApiserverTask() workflow.Task {
+func NewCheckApiserverHealthTask() workflow.Task {
 	return workflow.Task{
-		Name: "wait-apiserver",
+		Name: "check-apiserver-health",
 		Run:  runWaitApiserver,
 	}
 }
@@ -34,31 +34,17 @@ func NewWaitApiserverTask() workflow.Task {
 func runWaitApiserver(r workflow.RunData) error {
 	data, ok := r.(InitData)
 	if !ok {
-		return fmt.Errorf("wait-aipserver task invoked with an invalid data struct")
+		return fmt.Errorf("check-apiserver-health task invoked with an invalid data struct")
 	}
-	klog.V(4).InfoS("[wait-aipserver] Running task", "karmada", klog.KObj(data))
+	klog.V(4).InfoS("[check-apiserver-health] Running task", "karmada", klog.KObj(data))
 
 	waiter := apiclient.NewKarmadaWaiter(data.ControlplaneConifg(), data.RemoteClient(), time.Second*30)
 
-	// wait etcd, karmada apiserver and aggregated apiserver to ready
+	// check whether the karmada apiserver is health.
-	// as long as a replica of pod is ready, we consider the service available.
-	if err := waiter.WaitForSomePods(etcdLabels.String(), data.GetNamespace(), 1); err != nil {
-		return fmt.Errorf("waiting for etcd to ready timeout, err: %w", err)
-	}
-	if err := waiter.WaitForSomePods(karmadaApiserverLabels.String(), data.GetNamespace(), 1); err != nil {
-		return fmt.Errorf("waiting for karmada apiserver to ready timeout, err: %w", err)
-	}
-	err := waiter.WaitForSomePods(karmadaAggregatedAPIServerLabels.String(), data.GetNamespace(), 1)
-	if err != nil {
-		return fmt.Errorf("waiting for karmada aggregated apiserver to ready timeout, err: %w", err)
-	}
-
-	// check whether the karmada apiserver is running and health.
 	if err := apiclient.TryRunCommand(waiter.WaitForAPI, 3); err != nil {
-		return fmt.Errorf("the karmada apiserver is unhealth, err: %w", err)
+		return fmt.Errorf("the karmada apiserver is unhealthy, err: %w", err)
 	}
-
+	klog.V(2).InfoS("[check-apiserver-health] the etcd and karmada-apiserver is healthy", "karmada", klog.KObj(data))
-	klog.V(2).InfoS("[wait-aipserver] the etcd, karmada apiserver and aggregated apiserver is ready", "karmada", klog.KObj(data))
 	return nil
 }