Repository: karmada-io/karmada

Issue:
Implement Default Resource Interpreter for Kubernetes ReplicaSet
**What would you like to be added**:
This task involves implementing the default resource interpreter for the native Kubernetes ​​`ReplicaSet`​​ resource within the Karmada control plane. The interpreter will enable Karmada to understand ReplicaSet-specific semantics for multi-cluster propagation, including replica calculation, status aggregation, and health assessment.


**Why is this needed**:

Karmada's Resource Interpreter is responsible for interpreting custom resources' behaviors
. For native Kubernetes resources like ReplicaSet, Karmada requires built-in rules to properly handle operations such as replica scheduling across member clusters and status aggregation back to the control plane
. The ReplicaSet interpreter will ensure Karmada can manage ReplicaSet resources as effectively as it handles other native workloads like Deployment.

**Interfaces to Implement**
Flowing [ResourceInterpreter interfaces ](https://github.com/karmada-io/karmada/blob/a54ca87cabb4193930aa2512f19fecf8e0709fa9/pkg/resourceinterpreter/interpreter.go#L42-L81)need to be implemented:
- GetReplicas
- ReviseReplica
- GetDependencies
- ReflectStatus
- InterpretHealth
- AggregateStatus

Hints from issue comments:
@ryanwuer: /assign

Solution patch:
diff --git a/charts/OWNERS b/charts/OWNERS
index 24632ad87..061876039 100644
--- a/charts/OWNERS
+++ b/charts/OWNERS
@@ -5,9 +5,12 @@ reviewers:
 - jrkeen
 - pidb
 - Poor12
+- seanlaii
 - zhzhuang-zju
 approvers:
 - a7i
 - chaosi-zju
 - pidb
 - Poor12
+- seanlaii
+- zhzhuang-zju
diff --git a/docs/CHANGELOG/CHANGELOG-1.16.md b/docs/CHANGELOG/CHANGELOG-1.16.md
index 93f6a58f3..833d0816b 100644
--- a/docs/CHANGELOG/CHANGELOG-1.16.md
+++ b/docs/CHANGELOG/CHANGELOG-1.16.md
@@ -2,9 +2,9 @@
 <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
 **Table of Contents**  *generated with [DocToc](https://github.com/thlorenz/doctoc)*
 
-- [v1.16.0-alpha.1](#v1160-alpha1)
-  - [Downloads for v1.16.0-alpha.1](#downloads-for-v1160-alpha1)
-  - [Changelog since v1.15.0](#changelog-since-v1150)
+- [v1.16.0-alpha.2](#v1160-alpha2)
+  - [Downloads for v1.16.0-alpha.2](#downloads-for-v1160-alpha2)
+  - [Changelog since v1.16.0-alpha.1](#changelog-since-v1160-alpha1)
   - [Urgent Update Notes](#urgent-update-notes)
   - [Changes by Kind](#changes-by-kind)
     - [API Changes](#api-changes)
@@ -16,9 +16,61 @@
     - [Dependencies](#dependencies)
     - [Helm Charts](#helm-charts)
     - [Instrumentation](#instrumentation)
+- [v1.16.0-alpha.1](#v1160-alpha1)
+  - [Downloads for v1.16.0-alpha.1](#downloads-for-v1160-alpha1)
+  - [Changelog since v1.15.0](#changelog-since-v1150)
+  - [Urgent Update Notes](#urgent-update-notes-1)
+  - [Changes by Kind](#changes-by-kind-1)
+    - [API Changes](#api-changes-1)
+    - [Features & Enhancements](#features--enhancements-1)
+    - [Deprecation](#deprecation-1)
+    - [Bug Fixes](#bug-fixes-1)
+    - [Security](#security-1)
+  - [Other](#other-1)
+    - [Dependencies](#dependencies-1)
+    - [Helm Charts](#helm-charts-1)
+    - [Instrumentation](#instrumentation-1)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
+# v1.16.0-alpha.2
+## Downloads for v1.16.0-alpha.2
+
+Download v1.16.0-alpha.2 in the [v1.16.0-alpha.2 release page](https://github.com/karmada-io/karmada/releases/tag/v1.16.0-alpha.2).
+
+## Changelog since v1.16.0-alpha.1
+
+## Urgent Update Notes
+
+## Changes by Kind
+
+### API Changes
+None.
+
+### Features & Enhancements
+- `karmadactl`: The `init` command now supports customizing Karmada component command line flags. ([#6637](https://github.com/karmada-io/karmada/pull/6637), @luyb177)
+- `karmada-scheduler-estimator`: Introduce MaxAvailableComponentSetsRequest & MaxAvailableComponentSetsResponse for component scheduling. ([#6787](https://github.com/karmada-io/karmada/pull/6787), @seanlaii)
+- `karmada-scheduler`: Implemented `MaxAvailableComponentSets` interface for general estimator based on resource summary. ([#6812](https://github.com/karmada-io/karmada/pull/6812), @mszacillo)
+
+### Deprecation
+None.
+
+### Bug Fixes
+- `karmada-metrics-adapter`: Fixed a panic when querying node metrics by name caused by using the wrong GroupVersionResource (PodsGVR instead of NodesGVR) when creating a lister. ([#6838](https://github.com/karmada-io/karmada/pull/6838), @vie-serendipity)
+
+### Security
+None.
+
+## Other
+### Dependencies
+- The base image `alpine` now has been promoted from 3.22.1 to 3.22.2. ([#6822](https://github.com/karmada-io/karmada/pull/6822))
+
+### Helm Charts
+None.
+
+### Instrumentation
+None.
+
 # v1.16.0-alpha.1
 ## Downloads for v1.16.0-alpha.1
 
diff --git a/pkg/estimator/server/server.go b/pkg/estimator/server/server.go
index 67da4735c..22a4ee5ed 100644
--- a/pkg/estimator/server/server.go
+++ b/pkg/estimator/server/server.go
@@ -223,6 +223,12 @@ func (es *AccurateSchedulerEstimatorServer) MaxAvailableReplicas(ctx context.Con
 	return &pb.MaxAvailableReplicasResponse{MaxReplicas: maxReplicas}, nil
 }
 
+// MaxAvailableComponentSets is the implementation of gRPC interface.
+// It returns the maximum number of complete multi-component sets (in terms of replicas) that each cluster can host.
+func (es *AccurateSchedulerEstimatorServer) MaxAvailableComponentSets(context.Context, *pb.MaxAvailableComponentSetsRequest) (*pb.MaxAvailableComponentSetsResponse, error) {
+	return &pb.MaxAvailableComponentSetsResponse{}, fmt.Errorf("not implemented yet")
+}
+
 // GetUnschedulableReplicas is the implementation of gRPC interface. It will return the
 // unschedulable replicas of a workload.
 func (es *AccurateSchedulerEstimatorServer) GetUnschedulableReplicas(ctx context.Context, request *pb.UnschedulableReplicasRequest) (response *pb.UnschedulableReplicasResponse, rerr error) {
diff --git a/pkg/estimator/service/mock_EstimatorClient.go b/pkg/estimator/service/mock_EstimatorClient.go
index b0abd4a05..959035443 100644
--- a/pkg/estimator/service/mock_EstimatorClient.go
+++ b/pkg/estimator/service/mock_EstimatorClient.go
@@ -138,6 +138,89 @@ func (_c *MockEstimatorClient_GetUnschedulableReplicas_Call) RunAndReturn(run fu
 	return _c
 }
 
+// MaxAvailableComponentSets provides a mock function for the type MockEstimatorClient
+func (_mock *MockEstimatorClient) MaxAvailableComponentSets(ctx context.Context, in *pb.MaxAvailableComponentSetsRequest, opts ...grpc.CallOption) (*pb.MaxAvailableComponentSetsResponse, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ctx, in, opts)
+	} else {
+		tmpRet = _mock.Called(ctx, in)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for MaxAvailableComponentSets")
+	}
+
+	var r0 *pb.MaxAvailableComponentSetsResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *pb.MaxAvailableComponentSetsRequest, ...grpc.CallOption) (*pb.MaxAvailableComponentSetsResponse, error)); ok {
+		return returnFunc(ctx, in, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *pb.MaxAvailableComponentSetsRequest, ...grpc.CallOption) *pb.MaxAvailableComponentSetsResponse); ok {
+		r0 = returnFunc(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*pb.MaxAvailableComponentSetsResponse)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *pb.MaxAvailableComponentSetsRequest, ...grpc.CallOption) error); ok {
+		r1 = returnFunc(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockEstimatorClient_MaxAvailableComponentSets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MaxAvailableComponentSets'
+type MockEstimatorClient_MaxAvailableComponentSets_Call struct {
+	*mock.Call
+}
+
+// MaxAvailableComponentSets is a helper method to define mock.On call
+//   - ctx context.Context
+//   - in *pb.MaxAvailableComponentSetsRequest
+//   - opts ...grpc.CallOption
+func (_e *MockEstimatorClient_Expecter) MaxAvailableComponentSets(ctx interface{}, in interface{}, opts ...interface{}) *MockEstimatorClient_MaxAvailableComponentSets_Call {
+	return &MockEstimatorClient_MaxAvailableComponentSets_Call{Call: _e.mock.On("MaxAvailableComponentSets",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *MockEstimatorClient_MaxAvailableComponentSets_Call) Run(run func(ctx context.Context, in *pb.MaxAvailableComponentSetsRequest, opts ...grpc.CallOption)) *MockEstimatorClient_MaxAvailableComponentSets_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 *pb.MaxAvailableComponentSetsRequest
+		if args[1] != nil {
+			arg1 = args[1].(*pb.MaxAvailableComponentSetsRequest)
+		}
+		var arg2 []grpc.CallOption
+		var variadicArgs []grpc.CallOption
+		if len(args) > 2 {
+			variadicArgs = args[2].([]grpc.CallOption)
+		}
+		arg2 = variadicArgs
+		run(
+			arg0,
+			arg1,
+			arg2...,
+		)
+	})
+	return _c
+}
+
+func (_c *MockEstimatorClient_MaxAvailableComponentSets_Call) Return(maxAvailableComponentSetsResponse *pb.MaxAvailableComponentSetsResponse, err error) *MockEstimatorClient_MaxAvailableComponentSets_Call {
+	_c.Call.Return(maxAvailableComponentSetsResponse, err)
+	return _c
+}
+
+func (_c *MockEstimatorClient_MaxAvailableComponentSets_Call) RunAndReturn(run func(ctx context.Context, in *pb.MaxAvailableComponentSetsRequest, opts ...grpc.CallOption) (*pb.MaxAvailableComponentSetsResponse, error)) *MockEstimatorClient_MaxAvailableComponentSets_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // MaxAvailableReplicas provides a mock function for the type MockEstimatorClient
 func (_mock *MockEstimatorClient) MaxAvailableReplicas(ctx context.Context, in *pb.MaxAvailableReplicasRequest, opts ...grpc.CallOption) (*pb.MaxAvailableReplicasResponse, error) {
 	var tmpRet mock.Arguments
diff --git a/pkg/estimator/service/service.pb.go b/pkg/estimator/service/service.pb.go
index fbaf6f448..b1b5d2471 100644
--- a/pkg/estimator/service/service.pb.go
+++ b/pkg/estimator/service/service.pb.go
@@ -28,20 +28,22 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 func init() { proto.RegisterFile("service.proto", fileDescriptor_a0b84a42fa06f626) }
 
 var fileDescriptor_a0b84a42fa06f626 = []byte{
-	// 205 bytes of a gzipped FileDescriptorProto
+	// 240 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x2d, 0x4e, 0x2d, 0x2a,
 	0xcb, 0x4c, 0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x32, 0x4e, 0xcf, 0x2c, 0xc9, 0x28,
 	0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0xcb, 0x4e, 0x2c, 0xca, 0x4d, 0x4c, 0x49, 0x8c, 0xcf, 0xcc,
 	0x87, 0x31, 0xf5, 0x0a, 0xb2, 0xd3, 0xf5, 0x52, 0x8b, 0x4b, 0x32, 0x73, 0x13, 0x4b, 0xf2, 0x8b,
 	0xf4, 0xa0, 0x5a, 0xa5, 0x14, 0x0a, 0xb2, 0xd3, 0xf5, 0xe1, 0xc2, 0xfa, 0x05, 0x49, 0xfa, 0xe9,
-	0xa9, 0x79, 0xa9, 0x45, 0x89, 0x25, 0xa9, 0x29, 0x10, 0x63, 0x8d, 0xfe, 0x32, 0x71, 0x71, 0xba,
+	0xa9, 0x79, 0xa9, 0x45, 0x89, 0x25, 0xa9, 0x29, 0x10, 0x63, 0x8d, 0x0e, 0xb1, 0x70, 0x71, 0xba,
 	0xc2, 0x14, 0x08, 0x6d, 0x66, 0xe4, 0x12, 0xf1, 0x4d, 0xac, 0x70, 0x2c, 0x4b, 0xcc, 0xcc, 0x49,
 	0x4c, 0xca, 0x49, 0x0d, 0x4a, 0x2d, 0xc8, 0xc9, 0x4c, 0x4e, 0x2c, 0x16, 0xf2, 0xd6, 0x23, 0xc5,
 	0xfa, 0x82, 0x24, 0x3d, 0x6c, 0xa6, 0x04, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97, 0x48, 0xf9, 0x50,
-	0xc7, 0xb0, 0xe2, 0x82, 0xfc, 0xbc, 0xe2, 0x54, 0x25, 0x06, 0xa1, 0x9d, 0x8c, 0x5c, 0x12, 0xee,
-	0xa9, 0x25, 0xa1, 0x79, 0xc5, 0xc9, 0x19, 0xa9, 0x29, 0xa5, 0xa8, 0x2e, 0x27, 0xd9, 0x32, 0xac,
-	0xc6, 0xc0, 0x9c, 0xee, 0x4b, 0x25, 0xd3, 0x60, 0x6e, 0x77, 0xe2, 0x8c, 0x62, 0x87, 0x46, 0x16,
-	0x20, 0x00, 0x00, 0xff, 0xff, 0x9f, 0xe1, 0x7a, 0x70, 0xf1, 0x01, 0x00, 0x00,
+	0xc7, 0xb0, 0xe2, 0x82, 0xfc, 0xbc, 0xe2, 0x54, 0x25, 0x06, 0xa1, 0x43, 0x8c, 0x5c, 0x92, 0xc8,
+	0x4a, 0x9c, 0xf3, 0x73, 0x0b, 0xf2, 0xf3, 0x52, 0xf3, 0x4a, 0x82, 0x53, 0x4b, 0x8a, 0x85, 0x02,
+	0x28, 0xb1, 0x0d, 0xc5, 0x28, 0x98, 0xfb, 0x03, 0xa9, 0x68, 0x22, 0xdc, 0x13, 0x3b, 0x19, 0xb9,
+	0x24, 0xdc, 0x53, 0x4b, 0x42, 0xf3, 0x8a, 0x93, 0x33, 0x52, 0x53, 0x4a, 0x51, 0x83, 0x9f, 0xe4,
+	0x10, 0xc3, 0x6a, 0x0c, 0xcc, 0xfd, 0xbe, 0x54, 0x32, 0x0d, 0xe6, 0x76, 0x27, 0xce, 0x28, 0x76,
+	0x68, 0x8a, 0x03, 0x04, 0x00, 0x00, 0xff, 0xff, 0xa2, 0x9f, 0x2a, 0xcf, 0xb6, 0x02, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -57,6 +59,7 @@ const _ = grpc.SupportPackageIsVersion4
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
 type EstimatorClient interface {
 	MaxAvailableReplicas(ctx context.Context, in *pb.MaxAvailableReplicasRequest, opts ...grpc.CallOption) (*pb.MaxAvailableReplicasResponse, error)
+	MaxAvailableComponentSets(ctx context.Context, in *pb.MaxAvailableComponentSetsRequest, opts ...grpc.CallOption) (*pb.MaxAvailableComponentSetsResponse, error)
 	GetUnschedulableReplicas(ctx context.Context, in *pb.UnschedulableReplicasRequest, opts ...grpc.CallOption) (*pb.UnschedulableReplicasResponse, error)
 }
 
@@ -77,6 +80,15 @@ func (c *estimatorClient) MaxAvailableReplicas(ctx context.Context, in *pb.MaxAv
 	return out, nil
 }
 
+func (c *estimatorClient) MaxAvailableComponentSets(ctx context.Context, in *pb.MaxAvailableComponentSetsRequest, opts ...grpc.CallOption) (*pb.MaxAvailableComponentSetsResponse, error) {
+	out := new(pb.MaxAvailableComponentSetsResponse)
+	err := c.cc.Invoke(ctx, "/github.com.karmada_io.karmada.pkg.estimator.service.Estimator/MaxAvailableComponentSets", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *estimatorClient) GetUnschedulableReplicas(ctx context.Context, in *pb.UnschedulableReplicasRequest, opts ...grpc.CallOption) (*pb.UnschedulableReplicasResponse, error) {
 	out := new(pb.UnschedulableReplicasResponse)
 	err := c.cc.Invoke(ctx, "/github.com.karmada_io.karmada.pkg.estimator.service.Estimator/GetUnschedulableReplicas", in, out, opts...)
@@ -89,6 +101,7 @@ func (c *estimatorClient) GetUnschedulableReplicas(ctx context.Context, in *pb.U
 // EstimatorServer is the server API for Estimator service.
 type EstimatorServer interface {
 	MaxAvailableReplicas(context.Context, *pb.MaxAvailableReplicasRequest) (*pb.MaxAvailableReplicasResponse, error)
+	MaxAvailableComponentSets(context.Context, *pb.MaxAvailableComponentSetsRequest) (*pb.MaxAvailableComponentSetsResponse, error)
 	GetUnschedulableReplicas(context.Context, *pb.UnschedulableReplicasRequest) (*pb.UnschedulableReplicasResponse, error)
 }
 
@@ -99,6 +112,9 @@ type UnimplementedEstimatorServer struct {
 func (*UnimplementedEstimatorServer) MaxAvailableReplicas(ctx context.Context, req *pb.MaxAvailableReplicasRequest) (*pb.MaxAvailableReplicasResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method MaxAvailableReplicas not implemented")
 }
+func (*UnimplementedEstimatorServer) MaxAvailableComponentSets(ctx context.Context, req *pb.MaxAvailableComponentSetsRequest) (*pb.MaxAvailableComponentSetsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MaxAvailableComponentSets not implemented")
+}
 func (*UnimplementedEstimatorServer) GetUnschedulableReplicas(ctx context.Context, req *pb.UnschedulableReplicasRequest) (*pb.UnschedulableReplicasResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetUnschedulableReplicas not implemented")
 }
@@ -125,6 +141,24 @@ func _Estimator_MaxAvailableReplicas_Handler(srv interface{}, ctx context.Contex
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Estimator_MaxAvailableComponentSets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(pb.MaxAvailableComponentSetsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(EstimatorServer).MaxAvailableComponentSets(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/github.com.karmada_io.karmada.pkg.estimator.service.Estimator/MaxAvailableComponentSets",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(EstimatorServer).MaxAvailableComponentSets(ctx, req.(*pb.MaxAvailableComponentSetsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Estimator_GetUnschedulableReplicas_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(pb.UnschedulableReplicasRequest)
 	if err := dec(in); err != nil {
@@ -151,6 +185,10 @@ var _Estimator_serviceDesc = grpc.ServiceDesc{
 			MethodName: "MaxAvailableReplicas",
 			Handler:    _Estimator_MaxAvailableReplicas_Handler,
 		},
+		{
+			MethodName: "MaxAvailableComponentSets",
+			Handler:    _Estimator_MaxAvailableComponentSets_Handler,
+		},
 		{
 			MethodName: "GetUnschedulableReplicas",
 			Handler:    _Estimator_GetUnschedulableReplicas_Handler,
diff --git a/pkg/estimator/service/service.proto b/pkg/estimator/service/service.proto
index 8ed1704d7..c4d40e43d 100644
--- a/pkg/estimator/service/service.proto
+++ b/pkg/estimator/service/service.proto
@@ -25,5 +25,6 @@ option go_package = "service";
 
 service Estimator {
   rpc MaxAvailableReplicas(pb.MaxAvailableReplicasRequest) returns (pb.MaxAvailableReplicasResponse) {}
+  rpc MaxAvailableComponentSets(pb.MaxAvailableComponentSetsRequest) returns (pb.MaxAvailableComponentSetsResponse) {}
   rpc GetUnschedulableReplicas(pb.UnschedulableReplicasRequest) returns (pb.UnschedulableReplicasResponse) {}
 }
diff --git a/pkg/karmadactl/cmdinit/cmdinit.go b/pkg/karmadactl/cmdinit/cmdinit.go
index 364d46c29..2b65a12e7 100644
--- a/pkg/karmadactl/cmdinit/cmdinit.go
+++ b/pkg/karmadactl/cmdinit/cmdinit.go
@@ -79,7 +79,42 @@ var (
 		%[1]s init --cert-external-ip 10.235.1.2 --cert-external-dns www.karmada.io
 
 		# Install Karmada using a configuration file
-		%[1]s init --config /path/to/your/config/file.yaml`)
+		%[1]s init --config /path/to/your/config/file.yaml
+		
+		# Pass extra arguments to Local Etcd. (Parameters are separated by commas)
+		%[1]s init --etcd-extra-args="--snapshot-count=5000,--heartbeat-interval=100"
+		# Or write them separately.
+		%[1]s init --etcd-extra-args="--snapshot-count=5000" --etcd-extra-args="--heartbeat-interval=100"
+
+		# Pass extra arguments to Karmada API Server. (Parameters are separated by commas)
+		%[1]s init --karmada-apiserver-extra-args="--tls-min-version=VersionTLS12,--audit-log-path=-"
+		# Or write them separately.
+		%[1]s init --karmada-apiserver-extra-args="--tls-min-version=VersionTLS12" --karmada-apiserver-extra-args="--audit-log-path=-"
+
+		# Pass extra arguments to Karmada Scheduler. (Parameters are separated by commas)
+		%[1]s init --karmada-scheduler-extra-args="--scheduler-name=test-scheduler,--enable-pprof"
+		# Or write them separately.
+		%[1]s init --karmada-scheduler-extra-args="--scheduler-name=test-scheduler" --karmada-scheduler-extra-args="--enable-pprof"
+
+		# Pass extra arguments to Kube Controller Manager. (Parameters are separated by commas)
+		%[1]s init --kube-controller-manager-extra-args="--node-monitor-grace-period=50s,--node-monitor-period=5s"
+		# Or write them separately.
+		%[1]s init --kube-controller-manager-extra-args="--node-monitor-grace-period=50s" --kube-controller-manager-extra-args="--node-monitor-period=5s"
+		
+		# Pass extra arguments to Karmada Controller Manager. (Parameters are separated by commas)
+		%[1]s init --karmada-controller-manager-extra-args="--v=2,--enable-pprof"
+		# Or write them separately.
+		%[1]s init --karmada-controller-manager-extra-args="--v=2" --karmada-controller-manager-extra-args="--enable-pprof"
+
+		# Pass extra arguments to Karmada Webhook. (Parameters are separated by commas)
+		%[1]s init --karmada-webhook-extra-args="--v=2,--enable-pprof"
+		# Or write them separately.
+		%[1]s init --karmada-webhook-extra-args="--v=2" --karmada-webhook-extra-args="--enable-pprof"
+
+		# Pass extra arguments to Karmada Aggregated API Server. (Parameters are separated by commas)
+		%[1]s init --karmada-aggregated-apiserver-extra-args="--v=4,--enable-pprof"
+		# Or write them separately.
+		%[1]s init --karmada-aggregated-apiserver-extra-args="--v=4" --karmada-aggregated-apiserver-extra-args="--enable-pprof"`)
 )
 
 // NewCmdInit install Karmada on Kubernetes
@@ -151,6 +186,7 @@ func NewCmdInit(parentCommand string) *cobra.Command {
 	flags.StringVar(&opts.ExternalEtcdServers, "external-etcd-servers", "", "The server urls of external etcd cluster, to be used by kube-apiserver through --etcd-servers.")
 	flags.StringVar(&opts.ExternalEtcdKeyPrefix, "external-etcd-key-prefix", "", "The key prefix to be configured to kube-apiserver through --etcd-prefix.")
 	flags.StringVar(&opts.EtcdPriorityClass, "etcd-priority-class", "system-node-critical", "The priority class name for the component etcd.")
+	flags.StringSliceVar(&opts.EtcdExtraArgs, "etcd-extra-args", nil, "Additional command line arguments to pass to the etcd component. Can be specified multiple times or as comma-separated values (e.g., '--snapshot-count=5000,--heartbeat-interval=100')")
 	// karmada
 	flags.StringVar(&opts.CRDs, "crds", kubernetes.DefaultCrdURL, "Karmada crds resource.(local file e.g. --crds /root/crds.tar.gz)")
 	flags.StringVar(&opts.KarmadaInitFilePath, "config", "", "Karmada init file path")
@@ -163,26 +199,32 @@ func NewCmdInit(parentCommand string) *cobra.Command {
 	flags.StringVarP(&opts.KarmadaAPIServerImage, "karmada-apiserver-image", "", "", "Kubernetes apiserver image")
 	flags.Int32VarP(&opts.KarmadaAPIServerReplicas, "karmada-apiserver-replicas", "", 1, "Karmada apiserver replica set")
 	flags.StringVar(&opts.KarmadaAPIServerPriorityClass, "karmada-apiserver-priority-class", "system-node-critical", "The priority class name for the component karmada-apiserver.")
+	flags.StringSliceVar(&opts.KarmadaAPIServerExtraArgs, "karmada-apiserver-extra-args", nil, "Additional command line arguments to pass to the karmada-apiserver component. Can be specified multiple times or as comma-separated values (e.g., '--tls-min-version=VersionTLS12,--audit-log-path=-')")
 	// karmada-scheduler
 	flags.StringVarP(&opts.KarmadaSchedulerImage, "karmada-scheduler-image", "", kubernetes.DefaultKarmadaSchedulerImage, "Karmada scheduler image")
 	flags.Int32VarP(&opts.KarmadaSchedulerReplicas, "karmada-scheduler-replicas", "", 1, "Karmada scheduler replica set")
 	flags.StringVar(&opts.KarmadaSchedulerPriorityClass, "karmada-scheduler-priority-class", "system-node-critical", "The priority class name for the component karmada-scheduler.")
+	flags.StringSliceVar(&opts.KarmadaSchedulerExtraArgs, "karmada-scheduler-extra-args", nil, "Additional command line arguments to pass to the karmada-scheduler component. Can be specified multiple times or as comma-separated values (e.g., '--scheduler-name=test-scheduler,--enable-pprof')")
 	// karmada-kube-controller-manager
 	flags.StringVarP(&opts.KubeControllerManagerImage, "karmada-kube-controller-manager-image", "", "", "Kubernetes controller manager image")
 	flags.Int32VarP(&opts.KubeControllerManagerReplicas, "karmada-kube-controller-manager-replicas", "", 1, "Karmada kube controller manager replica set")
 	flags.StringVar(&opts.KubeControllerManagerPriorityClass, "karmada-kube-controller-manager-priority-class", "system-node-critical", "The priority class name for the component karmada-kube-controller-manager.")
+	flags.StringSliceVar(&opts.KubeControllerManagerExtraArgs, "karmada-kube-controller-manager-extra-args", nil, "Additional command line arguments to pass to the karmada-kube-controller-manager component. Can be specified multiple times or as comma-separated values (e.g., '--node-monitor-grace-period=50s,--node-monitor-period=5s')")
 	// karamda-controller-manager
 	flags.StringVarP(&opts.KarmadaControllerManagerImage, "karmada-controller-manager-image", "", kubernetes.DefaultKarmadaControllerManagerImage, "Karmada controller manager image")
 	flags.Int32VarP(&opts.KarmadaControllerManagerReplicas, "karmada-controller-manager-replicas", "", 1, "Karmada controller manager replica set")
 	flags.StringVar(&opts.KarmadaControllerManagerPriorityClass, "karmada-controller-manager-priority-class", "system-node-critical", "The priority class name for the component karmada-controller-manager.")
+	flags.StringSliceVar(&opts.KarmadaControllerManagerExtraArgs, "karmada-controller-manager-extra-args", nil, "Additional command line arguments to pass to the karmada-controller-manager component. Can be specified multiple times or as comma-separated values (e.g., '--v=2,--enable-pprof')")
 	// karmada-webhook
 	flags.StringVarP(&opts.KarmadaWebhookImage, "karmada-webhook-image", "", kubernetes.DefaultKarmadaWebhookImage, "Karmada webhook image")
 	flags.Int32VarP(&opts.KarmadaWebhookReplicas, "karmada-webhook-replicas", "", 1, "Karmada webhook replica set")
 	flags.StringVar(&opts.KarmadaWebhookPriorityClass, "karmada-webhook-priority-class", "system-node-critical", "The priority class name for the component karmada-webhook.")
+	flags.StringSliceVar(&opts.KarmadaWebhookExtraArgs, "karmada-webhook-extra-args", nil, "Additional command line arguments to pass to the karmada-webhook component. Can be specified multiple times or as comma-separated values (e.g., '--v=2,--enable-pprof')")
 	// karmada-aggregated-apiserver
 	flags.StringVarP(&opts.KarmadaAggregatedAPIServerImage, "karmada-aggregated-apiserver-image", "", kubernetes.DefaultKarmadaAggregatedAPIServerImage, "Karmada aggregated apiserver image")
 	flags.Int32VarP(&opts.KarmadaAggregatedAPIServerReplicas, "karmada-aggregated-apiserver-replicas", "", 1, "Karmada aggregated apiserver replica set")
 	flags.StringVar(&opts.KarmadaAggregatedAPIServerPriorityClass, "karmada-aggregated-apiserver-priority-class", "system-node-critical", "The priority class name for the component karmada-aggregated-apiserver.")
+	flags.StringSliceVar(&opts.KarmadaAggregatedAPIServerExtraArgs, "karmada-aggregated-apiserver-extra-args", nil, "Additional command line arguments to pass to the karmada-aggregated-apiserver component. Can be specified multiple times or as comma-separated values (e.g., '--v=4,--enable-pprof')")
 
 	return cmd
 }
diff --git a/pkg/karmadactl/cmdinit/kubernetes/command.go b/pkg/karmadactl/cmdinit/kubernetes/command.go
new file mode 100644
index 000000000..9e7275b8c
--- /dev/null
+++ b/pkg/karmadactl/cmdinit/kubernetes/command.go
@@ -0,0 +1,193 @@
+/*
+Copyright 2025 The Karmada Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package kubernetes
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"github.com/karmada-io/karmada/pkg/karmadactl/cmdinit/options"
+	globaloptions "github.com/karmada-io/karmada/pkg/karmadactl/options"
+	"github.com/karmada-io/karmada/pkg/karmadactl/util"
+)
+
+func (i *CommandInitOption) defaultEtcdContainerCommand() []string {
+	etcdClusterConfig := ""
+	for v := int32(0); v < i.EtcdReplicas; v++ {
+		etcdClusterConfig += fmt.Sprintf("%s-%v=http://%s-%v.%s.%s.svc.%s:%v", etcdStatefulSetAndServiceName, v, etcdStatefulSetAndServiceName, v, etcdStatefulSetAndServiceName, i.Namespace, i.HostClusterDomain, etcdContainerServerPort) + ","
+	}
+
+	command := []string{
+		"/usr/local/bin/etcd",
+		fmt.Sprintf("--name=$(%s)", etcdEnvPodName),
+		fmt.Sprintf("--listen-peer-urls=http://$(%s):%v", etcdEnvPodIP, etcdContainerServerPort),
+		fmt.Sprintf("--listen-client-urls=https://$(%s):%v,http://127.0.0.1:%v", etcdEnvPodIP, etcdContainerClientPort, etcdContainerClientPort),
+		fmt.Sprintf("--advertise-client-urls=https://$(%s).%s.%s.svc.%s:%v", etcdEnvPodName, etcdStatefulSetAndServiceName, i.Namespace, i.HostClusterDomain, etcdContainerClientPort),
+		fmt.Sprintf("--initial-cluster=%s", strings.TrimRight(etcdClusterConfig, ",")),
+		"--initial-cluster-state=new",
+		"--client-cert-auth=true",
+		fmt.Sprintf("--cert-file=%s/%s.crt", karmadaCertsVolumeMountPath, options.EtcdServerCertAndKeyName),
+		fmt.Sprintf("--key-file=%s/%s.key", karmadaCertsVolumeMountPath, options.EtcdServerCertAndKeyName),
+		fmt.Sprintf("--trusted-ca-file=%s/%s.crt", karmadaCertsVolumeMountPath, options.EtcdCaCertAndKeyName),
+		fmt.Sprintf("--data-dir=%s", etcdContainerDataVolumeMountPath),
+		fmt.Sprintf("--cipher-suites=%s", etcdCipherSuites),
+		"--initial-cluster-token=etcd-cluster",
+		fmt.Sprintf("--initial-advertise-peer-urls=http://$(%s):%v", etcdEnvPodIP, etcdContainerServerPort),
+		"--peer-client-cert-auth=false",
+		fmt.Sprintf("--peer-trusted-ca-file=%s/%s.crt", karmadaCertsVolumeMountPath, options.EtcdCaCertAndKeyName),
+		fmt.Sprintf("--peer-key-file=%s/%s.key", karmadaCertsVolumeMountPath, options.EtcdServerCertAndKeyName),
+		fmt.Sprintf("--peer-cert-file=%s/%s.crt", karmadaCertsVolumeMountPath, options.EtcdServerCertAndKeyName),
+	}
+	return command
+}
+
+func (i *CommandInitOption) defaultKarmadaAPIServerContainerCommand() []string {
+	var etcdServers string
+	if etcdServers = i.ExternalEtcdServers; etcdServers == "" {
+		etcdServers = strings.TrimRight(i.etcdServers(), ",")
+	}
+	command := []string{
+		"kube-apiserver",
+		"--allow-privileged=true",
+		"--authorization-mode=Node,RBAC",
+		fmt.Sprintf("--client-ca-file=%s/%s.crt", karmadaCertsVolumeMountPath, globaloptions.CaCertAndKeyName),
+		"--enable-bootstrap-token-auth=true",
+		fmt.Sprintf("--etcd-cafile=%s/%s.crt", karmadaCertsVolumeMountPath, options.EtcdCaCertAndKeyName),
+		fmt.Sprintf("--etcd-certfile=%s/%s.crt", karmadaCertsVolumeMountPath, options.EtcdClientCertAndKeyName),
+		fmt.Sprintf("--etcd-keyfile=%s/%s.key", karmadaCertsVolumeMountPath, options.EtcdClientCertAndKeyName),
+		fmt.Sprintf("--etcd-servers=%s", etcdServers),
+		"--bind-address=0.0.0.0",
+		"--disable-admission-plugins=StorageObjectInUseProtection,ServiceAccount",
+		"--runtime-config=",
+		fmt.Sprintf("--apiserver-count=%v", i.KarmadaAPIServerReplicas),
+		fmt.Sprintf("--secure-port=%v", karmadaAPIServerContainerPort),
+		fmt.Sprintf("--service-account-issuer=https://kubernetes.default.svc.%s", i.HostClusterDomain),
+		fmt.Sprintf("--service-account-key-file=%s/%s.key", karmadaCertsVolumeMountPath, options.KarmadaCertAndKeyName),
+		fmt.Sprintf("--service-account-signing-key-file=%s/%s.key", karmadaCertsVolumeMountPath, options.KarmadaCertAndKeyName),
+		fmt.Sprintf("--service-cluster-ip-range=%s", serviceClusterIP),
+		fmt.Sprintf("--proxy-client-cert-file=%s/%s.crt", karmadaCertsVolumeMountPath, options.FrontProxyClientCertAndKeyName),
+		fmt.Sprintf("--proxy-client-key-file=%s/%s.key", karmadaCertsVolumeMountPath, options.FrontProxyClientCertAndKeyName),
+		"--requestheader-allowed-names=front-proxy-client",
+		fmt.Sprintf("--requestheader-client-ca-file=%s/%s.crt", karmadaCertsVolumeMountPath, options.FrontProxyCaCertAndKeyName),
+		"--requestheader-extra-headers-prefix=X-Remote-Extra-",
+		"--requestheader-group-headers=X-Remote-Group",
+		"--requestheader-username-headers=X-Remote-User",
+		fmt.Sprintf("--tls-cert-file=%s/%s.crt", karmadaCertsVolumeMountPath, options.ApiserverCertAndKeyName),
+		fmt.Sprintf("--tls-private-key-file=%s/%s.key", karmadaCertsVolumeMountPath, options.ApiserverCertAndKeyName),
+		"--tls-min-version=VersionTLS13",
+	}
+	if i.ExternalEtcdKeyPrefix != "" {
+		command = append(command, fmt.Sprintf("--etcd-prefix=%s", i.ExternalEtcdKeyPrefix))
+	}
+	return command
+}
+
+func (i *CommandInitOption) defaultKarmadaSchedulerContainerCommand() []string {
+	return []string{
+		"/bin/karmada-scheduler",
+		fmt.Sprintf("--kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
+		"--metrics-bind-address=$(POD_IP):8080",
+		"--health-probe-bind-address=$(POD_IP):10351",
+		"--enable-scheduler-estimator=true",
+		"--leader-elect=true",
+		"--scheduler-estimator-ca-file=/etc/karmada/pki/ca.crt",
+		"--scheduler-estimator-cert-file=/etc/karmada/pki/karmada.crt",
+		"--scheduler-estimator-key-file=/etc/karmada/pki/karmada.key",
+		fmt.Sprintf("--leader-elect-resource-namespace=%s", i.Namespace),
+		"--v=4",
+	}
+}
+
+// default command line arguments for kube-controller-manager
+func (i *CommandInitOption) defaultKarmadaKubeControllerManagerContainerCommand() []string {
+	return []string{
+		"kube-controller-manager",
+		"--allocate-node-cidrs=true",
+		fmt.Sprintf("--kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
+		fmt.Sprintf("--authentication-kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
+		fmt.Sprintf("--authorization-kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
+		"--bind-address=0.0.0.0",
+		fmt.Sprintf("--client-ca-file=%s/%s.crt", karmadaCertsVolumeMountPath, globaloptions.CaCertAndKeyName),
+		"--cluster-cidr=10.244.0.0/16",
+		fmt.Sprintf("--cluster-name=%s", options.ClusterName),
+		fmt.Sprintf("--cluster-signing-cert-file=%s/%s.crt", karmadaCertsVolumeMountPath, globaloptions.CaCertAndKeyName),
+		fmt.Sprintf("--cluster-signing-key-file=%s/%s.key", karmadaCertsVolumeMountPath, globaloptions.CaCertAndKeyName),
+		"--controllers=namespace,garbagecollector,serviceaccount-token,ttl-after-finished,bootstrapsigner,tokencleaner,csrcleaner,csrsigning,clusterrole-aggregation",
+		"--leader-elect=true",
+		fmt.Sprintf("--leader-elect-resource-namespace=%s", i.Namespace),
+		"--node-cidr-mask-size=24",
+		fmt.Sprintf("--root-ca-file=%s/%s.crt", karmadaCertsVolumeMountPath, globaloptions.CaCertAndKeyName),
+		fmt.Sprintf("--service-account-private-key-file=%s/%s.key", karmadaCertsVolumeMountPath, options.KarmadaCertAndKeyName),
+		fmt.Sprintf("--service-cluster-ip-range=%s", serviceClusterIP),
+		"--use-service-account-credentials=true",
+		"--v=4",
+	}
+}
+
+func (i *CommandInitOption) defaultKarmadaControllerManagerContainerCommand() []string {
+	return []string{
+		"/bin/karmada-controller-manager",
+		fmt.Sprintf("--kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
+		"--metrics-bind-address=$(POD_IP):8080",
+		"--health-probe-bind-address=$(POD_IP):10357",
+		"--cluster-status-update-frequency=10s",
+		fmt.Sprintf("--leader-elect-resource-namespace=%s", i.Namespace),
+		"--v=4",
+	}
+}
+
+func (i *CommandInitOption) defaultKarmadaWebhookContainerCommand() []string {
+	return []string{
+		"/bin/karmada-webhook",
+		fmt.Sprintf("--kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
+		"--bind-address=$(POD_IP)",
+		"--metrics-bind-address=$(POD_IP):8080",
+		"--health-probe-bind-address=$(POD_IP):8000",
+		fmt.Sprintf("--secure-port=%v", webhookTargetPort),
+		fmt.Sprintf("--cert-dir=%s", webhookCertVolumeMountPath),
+		"--v=4",
+	}
+}
+
+func (i *CommandInitOption) defaultKarmadaAggregatedAPIServerContainerCommand() []string {
+	var etcdServers string
+	if etcdServers = i.ExternalEtcdServers; etcdServers == "" {
+		etcdServers = strings.TrimRight(i.etcdServers(), ",")
+	}
+	command := []string{
+		"/bin/karmada-aggregated-apiserver",
+		fmt.Sprintf("--kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
+		fmt.Sprintf("--authentication-kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
+		fmt.Sprintf("--authorization-kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
+		fmt.Sprintf("--etcd-servers=%s", etcdServers),
+		fmt.Sprintf("--etcd-cafile=%s/%s.crt", karmadaCertsVolumeMountPath, options.EtcdCaCertAndKeyName),
+		fmt.Sprintf("--etcd-certfile=%s/%s.crt", karmadaCertsVolumeMountPath, options.EtcdClientCertAndKeyName),
+		fmt.Sprintf("--etcd-keyfile=%s/%s.key", karmadaCertsVolumeMountPath, options.EtcdClientCertAndKeyName),
+		fmt.Sprintf("--tls-cert-file=%s/%s.crt", karmadaCertsVolumeMountPath, options.KarmadaCertAndKeyName),
+		fmt.Sprintf("--tls-private-key-file=%s/%s.key", karmadaCertsVolumeMountPath, options.KarmadaCertAndKeyName),
+		"--tls-min-version=VersionTLS13",
+		"--audit-log-path=-",
+		"--audit-log-maxage=0",
+		"--audit-log-maxbackup=0",
+		"--bind-address=$(POD_IP)",
+	}
+	if i.ExternalEtcdKeyPrefix != "" {
+		command = append(command, fmt.Sprintf("--etcd-prefix=%s", i.ExternalEtcdKeyPrefix))
+	}
+	return command
+}
diff --git a/pkg/karmadactl/cmdinit/kubernetes/deploy.go b/pkg/karmadactl/cmdinit/kubernetes/deploy.go
index 8fd1d7910..bdb01f5b8 100644
--- a/pkg/karmadactl/cmdinit/kubernetes/deploy.go
+++ b/pkg/karmadactl/cmdinit/kubernetes/deploy.go
@@ -154,6 +154,8 @@ type CommandInitOption struct {
 	EtcdNodeSelectorLabelsMap map[string]string
 	EtcdPersistentVolumeSize  string
 	EtcdPriorityClass         string
+	EtcdExtraArgs             []string
+	EtcdContainerCmd          []string // The command for containers in a Pod.
 
 	// external etcd
 	ExternalEtcdCACertPath     string
@@ -169,30 +171,43 @@ type CommandInitOption struct {
 	KarmadaAPIServerNodePort         int32
 	KarmadaAPIServerIP               []net.IP
 	KarmadaAPIServerPriorityClass    string
+	KarmadaAPIServerExtraArgs        []string
+	KarmadaAPIServerContainerCmd     []string
 
 	// karmada-scheduler
 	KarmadaSchedulerImage         string
 	KarmadaSchedulerReplicas      int32
 	KarmadaSchedulerPriorityClass string
+	KarmadaSchedulerExtraArgs     []string
+	KarmadaSchedulerContainerCmd  []string
 
 	// kube-controller-manager
 	KubeControllerManagerImage         string
 	KubeControllerManagerReplicas      int32
 	KubeControllerManagerPriorityClass string
+	KubeControllerManagerExtraArgs     []string
+	KubeControllerManagerContainerCmd  []string
 
 	// karmada-controller-manager
 	KarmadaControllerManagerImage         string
 	KarmadaControllerManagerReplicas      int32
 	KarmadaControllerManagerPriorityClass string
+	KarmadaControllerManagerExtraArgs     []string
+	KarmadaControllerManagerContainerCmd  []string
 
+	// karmada-webhook
 	KarmadaWebhookImage         string
 	KarmadaWebhookReplicas      int32
 	KarmadaWebhookPriorityClass string
+	KarmadaWebhookExtraArgs     []string
+	KarmadaWebhookContainerCmd  []string
 
 	// karamda-aggregated-apiserver
 	KarmadaAggregatedAPIServerImage         string
 	KarmadaAggregatedAPIServerReplicas      int32
 	KarmadaAggregatedAPIServerPriorityClass string
+	KarmadaAggregatedAPIServerExtraArgs     []string
+	KarmadaAggregatedAPIServerContainerCmd  []string
 
 	Namespace          string
 	KubeConfig         string
@@ -257,8 +272,44 @@ func (i *CommandInitOption) isExternalEtcdProvided() bool {
 	return i.ExternalEtcdServers != ""
 }
 
+// validateCommandLineArgs The parameters that are successfully validated will be reassigned to the corresponding xxxExtraArgs.
+func (i *CommandInitOption) validateCommandLineArgs() error {
+	type validateCommandLine struct {
+		name                string
+		additionCommandLine *[]string // addition
+	}
+
+	validateCommandLines := []validateCommandLine{
+		{names.KarmadaEtcdComponentName, &i.EtcdExtraArgs},
+		{names.KarmadaAPIServerComponentName, &i.KarmadaAPIServerExtraArgs},
+		{names.KarmadaSchedulerComponentName, &i.KarmadaSchedulerExtraArgs},
+		{names.KubeControllerManagerComponentName, &i.KubeControllerManagerExtraArgs},
+		{names.KarmadaControllerManagerComponentName, &i.KarmadaControllerManagerExtraArgs},
+		{names.KarmadaWebhookComponentName, &i.KarmadaWebhookExtraArgs},
+		{names.KarmadaAggregatedAPIServerComponentName, &i.KarmadaAggregatedAPIServerExtraArgs},
+	}
+	// validate case -> vc
+	for _, vc := range validateCommandLines {
+		if *vc.additionCommandLine != nil {
+			var err error
+			*vc.additionCommandLine, err = utils.ValidateExtraArgs(*vc.additionCommandLine)
+			if err != nil {
+				klog.Errorf("validate %s extra args failed: %v", vc.name, err)
+				return err
+			}
+		}
+	}
+	return nil
+}
+
 // Validate Check that there are enough flags to run the command.
 func (i *CommandInitOption) Validate(parentCommand string) error {
+	// validate command line args
+	err := i.validateCommandLineArgs()
+	if err != nil {
+		return err
+	}
+
 	if i.KarmadaInitFilePath != "" {
 		cfg, err := initConfig.LoadInitConfiguration(i.KarmadaInitFilePath)
 		if err != nil {
@@ -333,9 +384,40 @@ func (i *CommandInitOption) Complete() error {
 			}
 		}
 	}
+
+	i.initializeCommandLineArgs()
+
 	return initializeDirectory(i.KarmadaDataPath)
 }
 
+// initializeCommandLineArgs Merge default parameters and validated user parameters.
+func (i *CommandInitOption) initializeCommandLineArgs() {
+	type mergeCommandLine struct {
+		name                string
+		finalCommandLine    *[]string
+		defaultCommandLine  func() []string
+		additionCommandLine []string
+	}
+
+	mergeCommandLines := []mergeCommandLine{
+		{names.KarmadaEtcdComponentName, &i.EtcdContainerCmd, i.defaultEtcdContainerCommand, i.EtcdExtraArgs},
+		{names.KarmadaAPIServerComponentName, &i.KarmadaAPIServerContainerCmd, i.defaultKarmadaAPIServerContainerCommand, i.KarmadaAPIServerExtraArgs},
+		{names.KarmadaSchedulerComponentName, &i.KarmadaSchedulerContainerCmd, i.defaultKarmadaSchedulerContainerCommand, i.KarmadaSchedulerExtraArgs},
+		{names.KubeControllerManagerComponentName, &i.KubeControllerManagerContainerCmd, i.defaultKarmadaKubeControllerManagerContainerCommand, i.KubeControllerManagerExtraArgs},
+		{names.KarmadaControllerManagerComponentName, &i.KarmadaControllerManagerContainerCmd, i.defaultKarmadaControllerManagerContainerCommand, i.KarmadaControllerManagerExtraArgs},
+		{names.KarmadaWebhookComponentName, &i.KarmadaWebhookContainerCmd, i.defaultKarmadaWebhookContainerCommand, i.KarmadaWebhookExtraArgs},
+		{names.KarmadaAggregatedAPIServerComponentName, &i.KarmadaAggregatedAPIServerContainerCmd, i.defaultKarmadaAggregatedAPIServerContainerCommand, i.KarmadaAggregatedAPIServerExtraArgs},
+	}
+
+	for _, mc := range mergeCommandLines {
+		if mc.additionCommandLine != nil {
+			*mc.finalCommandLine = utils.MergeCommandArgs(mc.defaultCommandLine(), mc.additionCommandLine)
+		} else {
+			*mc.finalCommandLine = mc.defaultCommandLine()
+		}
+	}
+}
+
 // initializeDirectory initializes a directory and makes sure it's empty.
 func initializeDirectory(path string) error {
 	if utils.IsExist(path) {
diff --git a/pkg/karmadactl/cmdinit/kubernetes/deployments.go b/pkg/karmadactl/cmdinit/kubernetes/deployments.go
index dac095c9e..97c45eb2a 100644
--- a/pkg/karmadactl/cmdinit/kubernetes/deployments.go
+++ b/pkg/karmadactl/cmdinit/kubernetes/deployments.go
@@ -18,8 +18,6 @@ package kubernetes
 
 import (
 	"fmt"
-	"path/filepath"
-	"strings"
 
 	appsv1 "k8s.io/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
@@ -28,7 +26,6 @@ import (
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/utils/ptr"
 
-	"github.com/karmada-io/karmada/pkg/karmadactl/cmdinit/options"
 	globaloptions "github.com/karmada-io/karmada/pkg/karmadactl/options"
 	"github.com/karmada-io/karmada/pkg/karmadactl/util"
 	"github.com/karmada-io/karmada/pkg/util/names"
@@ -78,47 +75,6 @@ func (i *CommandInitOption) etcdServers() string {
 	return etcdClusterConfig
 }
 
-func (i *CommandInitOption) karmadaAPIServerContainerCommand() []string {
-	var etcdServers string
-	if etcdServers = i.ExternalEtcdServers; etcdServers == "" {
-		etcdServers = strings.TrimRight(i.etcdServers(), ",")
-	}
-	command := []string{
-		"kube-apiserver",
-		"--allow-privileged=true",
-		"--authorization-mode=Node,RBAC",
-		fmt.Sprintf("--client-ca-file=%s/%s.crt", karmadaCertsVolumeMountPath, globaloptions.CaCertAndKeyName),
-		"--enable-bootstrap-token-auth=true",
-		fmt.Sprintf("--etcd-cafile=%s/%s.crt", karmadaCertsVolumeMountPath, options.EtcdCaCertAndKeyName),
-		fmt.Sprintf("--etcd-certfile=%s/%s.crt", karmadaCertsVolumeMountPath, options.EtcdClientCertAndKeyName),
-		fmt.Sprintf("--etcd-keyfile=%s/%s.key", karmadaCertsVolumeMountPath, options.EtcdClientCertAndKeyName),
-		fmt.Sprintf("--etcd-servers=%s", etcdServers),
-		"--bind-address=0.0.0.0",
-		"--disable-admission-plugins=StorageObjectInUseProtection,ServiceAccount",
-		"--runtime-config=",
-		fmt.Sprintf("--apiserver-count=%v", i.KarmadaAPIServerReplicas),
-		fmt.Sprintf("--secure-port=%v", karmadaAPIServerContainerPort),
-		fmt.Sprintf("--service-account-issuer=https://kubernetes.default.svc.%s", i.HostClusterDomain),
-		fmt.Sprintf("--service-account-key-file=%s/%s.key", karmadaCertsVolumeMountPath, options.KarmadaCertAndKeyName),
-		fmt.Sprintf("--service-account-signing-key-file=%s/%s.key", karmadaCertsVolumeMountPath, options.KarmadaCertAndKeyName),
-		fmt.Sprintf("--service-cluster-ip-range=%s", serviceClusterIP),
-		fmt.Sprintf("--proxy-client-cert-file=%s/%s.crt", karmadaCertsVolumeMountPath, options.FrontProxyClientCertAndKeyName),
-		fmt.Sprintf("--proxy-client-key-file=%s/%s.key", karmadaCertsVolumeMountPath, options.FrontProxyClientCertAndKeyName),
-		"--requestheader-allowed-names=front-proxy-client",
-		fmt.Sprintf("--requestheader-client-ca-file=%s/%s.crt", karmadaCertsVolumeMountPath, options.FrontProxyCaCertAndKeyName),
-		"--requestheader-extra-headers-prefix=X-Remote-Extra-",
-		"--requestheader-group-headers=X-Remote-Group",
-		"--requestheader-username-headers=X-Remote-User",
-		fmt.Sprintf("--tls-cert-file=%s/%s.crt", karmadaCertsVolumeMountPath, options.ApiserverCertAndKeyName),
-		fmt.Sprintf("--tls-private-key-file=%s/%s.key", karmadaCertsVolumeMountPath, options.ApiserverCertAndKeyName),
-		"--tls-min-version=VersionTLS13",
-	}
-	if i.ExternalEtcdKeyPrefix != "" {
-		command = append(command, fmt.Sprintf("--etcd-prefix=%s", i.ExternalEtcdKeyPrefix))
-	}
-	return command
-}
-
 func (i *CommandInitOption) makeKarmadaAPIServerDeployment() *appsv1.Deployment {
 	apiServer := &appsv1.Deployment{
 		TypeMeta: metav1.TypeMeta{
@@ -189,7 +145,7 @@ func (i *CommandInitOption) makeKarmadaAPIServerDeployment() *appsv1.Deployment
 			{
 				Name:    karmadaAPIServerDeploymentAndServiceName,
 				Image:   i.kubeAPIServerImage(),
-				Command: i.karmadaAPIServerContainerCommand(),
+				Command: i.KarmadaAPIServerContainerCmd,
 				Ports: []corev1.ContainerPort{
 					{
 						Name:          portName,
@@ -302,30 +258,9 @@ func (i *CommandInitOption) makeKarmadaKubeControllerManagerDeployment() *appsv1
 		AutomountServiceAccountToken: ptr.To[bool](false),
 		Containers: []corev1.Container{
 			{
-				Name:  kubeControllerManagerClusterRoleAndDeploymentAndServiceName,
-				Image: i.kubeControllerManagerImage(),
-				Command: []string{
-					"kube-controller-manager",
-					"--allocate-node-cidrs=true",
-					fmt.Sprintf("--kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
-					fmt.Sprintf("--authentication-kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
-					fmt.Sprintf("--authorization-kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
-					"--bind-address=0.0.0.0",
-					fmt.Sprintf("--client-ca-file=%s/%s.crt", karmadaCertsVolumeMountPath, globaloptions.CaCertAndKeyName),
-					"--cluster-cidr=10.244.0.0/16",
-					fmt.Sprintf("--cluster-name=%s", options.ClusterName),
-					fmt.Sprintf("--cluster-signing-cert-file=%s/%s.crt", karmadaCertsVolumeMountPath, globaloptions.CaCertAndKeyName),
-					fmt.Sprintf("--cluster-signing-key-file=%s/%s.key", karmadaCertsVolumeMountPath, globaloptions.CaCertAndKeyName),
-					"--controllers=namespace,garbagecollector,serviceaccount-token,ttl-after-finished,bootstrapsigner,tokencleaner,csrcleaner,csrsigning,clusterrole-aggregation",
-					"--leader-elect=true",
-					fmt.Sprintf("--leader-elect-resource-namespace=%s", i.Namespace),
-					"--node-cidr-mask-size=24",
-					fmt.Sprintf("--root-ca-file=%s/%s.crt", karmadaCertsVolumeMountPath, globaloptions.CaCertAndKeyName),
-					fmt.Sprintf("--service-account-private-key-file=%s/%s.key", karmadaCertsVolumeMountPath, options.KarmadaCertAndKeyName),
-					fmt.Sprintf("--service-cluster-ip-range=%s", serviceClusterIP),
-					"--use-service-account-credentials=true",
-					"--v=4",
-				},
+				Name:          kubeControllerManagerClusterRoleAndDeploymentAndServiceName,
+				Image:         i.kubeControllerManagerImage(),
+				Command:       i.KubeControllerManagerContainerCmd,
 				LivenessProbe: livenessProbe,
 				Ports: []corev1.ContainerPort{
 					{
@@ -460,19 +395,7 @@ func (i *CommandInitOption) makeKarmadaSchedulerDeployment() *appsv1.Deployment
 						},
 					},
 				},
-				Command: []string{
-					"/bin/karmada-scheduler",
-					fmt.Sprintf("--kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
-					"--metrics-bind-address=$(POD_IP):8080",
-					"--health-probe-bind-address=$(POD_IP):10351",
-					"--enable-scheduler-estimator=true",
-					"--leader-elect=true",
-					"--scheduler-estimator-ca-file=/etc/karmada/pki/ca.crt",
-					"--scheduler-estimator-cert-file=/etc/karmada/pki/karmada.crt",
-					"--scheduler-estimator-key-file=/etc/karmada/pki/karmada.key",
-					fmt.Sprintf("--leader-elect-resource-namespace=%s", i.Namespace),
-					"--v=4",
-				},
+				Command:       i.KarmadaSchedulerContainerCmd,
 				LivenessProbe: livenessProbe,
 				Ports: []corev1.ContainerPort{
 					{
@@ -609,15 +532,7 @@ func (i *CommandInitOption) makeKarmadaControllerManagerDeployment() *appsv1.Dep
 						},
 					},
 				},
-				Command: []string{
-					"/bin/karmada-controller-manager",
-					fmt.Sprintf("--kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
-					"--metrics-bind-address=$(POD_IP):8080",
-					"--health-probe-bind-address=$(POD_IP):10357",
-					"--cluster-status-update-frequency=10s",
-					fmt.Sprintf("--leader-elect-resource-namespace=%s", i.Namespace),
-					"--v=4",
-				},
+				Command:       i.KarmadaControllerManagerContainerCmd,
 				LivenessProbe: livenessProbe,
 				Ports: []corev1.ContainerPort{
 					{
@@ -743,16 +658,7 @@ func (i *CommandInitOption) makeKarmadaWebhookDeployment() *appsv1.Deployment {
 						},
 					},
 				},
-				Command: []string{
-					"/bin/karmada-webhook",
-					fmt.Sprintf("--kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
-					"--bind-address=$(POD_IP)",
-					"--metrics-bind-address=$(POD_IP):8080",
-					"--health-probe-bind-address=$(POD_IP):8000",
-					fmt.Sprintf("--secure-port=%v", webhookTargetPort),
-					fmt.Sprintf("--cert-dir=%s", webhookCertVolumeMountPath),
-					"--v=4",
-				},
+				Command: i.KarmadaWebhookContainerCmd,
 				Ports: []corev1.ContainerPort{
 					{
 						Name:          webhookPortName,
@@ -870,30 +776,6 @@ func (i *CommandInitOption) makeKarmadaAggregatedAPIServerDeployment() *appsv1.D
 		TimeoutSeconds:      15,
 	}
 
-	var etcdServers string
-	if etcdServers = i.ExternalEtcdServers; etcdServers == "" {
-		etcdServers = strings.TrimRight(i.etcdServers(), ",")
-	}
-	command := []string{
-		"/bin/karmada-aggregated-apiserver",
-		fmt.Sprintf("--kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
-		fmt.Sprintf("--authentication-kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
-		fmt.Sprintf("--authorization-kubeconfig=%s", filepath.Join(karmadaConfigVolumeMountPath, util.KarmadaConfigFieldName)),
-		fmt.Sprintf("--etcd-servers=%s", etcdServers),
-		fmt.Sprintf("--etcd-cafile=%s/%s.crt", karmadaCertsVolumeMountPath, options.EtcdCaCertAndKeyName),
-		fmt.Sprintf("--etcd-certfile=%s/%s.crt", karmadaCertsVolumeMountPath, options.EtcdClientCertAndKeyName),
-		fmt.Sprintf("--etcd-keyfile=%s/%s.key", karmadaCertsVolumeMountPath, options.EtcdClientCertAndKeyName),
-		fmt.Sprintf("--tls-cert-file=%s/%s.crt", karmadaCertsVolumeMountPath, options.KarmadaCertAndKeyName),
-		fmt.Sprintf("--tls-private-key-file=%s/%s.key", karmadaCertsVolumeMountPath, options.KarmadaCertAndKeyName),
-		"--tls-min-version=VersionTLS13",
-		"--audit-log-path=-",
-		"--audit-log-maxage=0",
-		"--audit-log-maxbackup=0",
-		"--bind-address=$(POD_IP)",
-	}
-	if i.ExternalEtcdKeyPrefix != "" {
-		command = append(command, fmt.Sprintf("--etcd-prefix=%s", i.ExternalEtcdKeyPrefix))
-	}
 	podSpec := corev1.PodSpec{
 		ImagePullSecrets:  i.getImagePullSecrets(),
 		PriorityClassName: i.KarmadaAggregatedAPIServerPriorityClass,
@@ -931,7 +813,7 @@ func (i *CommandInitOption) makeKarmadaAggregatedAPIServerDeployment() *appsv1.D
 						},
 					},
 				},
-				Command:        command,
+				Command:        i.KarmadaAggregatedAPIServerContainerCmd,
 				ReadinessProbe: readinesProbe,
 				LivenessProbe:  livenesProbe,
 				Resources: corev1.ResourceRequirements{
diff --git a/pkg/karmadactl/cmdinit/kubernetes/statefulset.go b/pkg/karmadactl/cmdinit/kubernetes/statefulset.go
index 10bbc3359..dc846e610 100644
--- a/pkg/karmadactl/cmdinit/kubernetes/statefulset.go
+++ b/pkg/karmadactl/cmdinit/kubernetes/statefulset.go
@@ -26,8 +26,6 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/component-base/cli/flag"
 	"k8s.io/utils/ptr"
-
-	"github.com/karmada-io/karmada/pkg/karmadactl/cmdinit/options"
 )
 
 const (
@@ -127,63 +125,6 @@ func (i *CommandInitOption) etcdVolume() (*[]corev1.Volume, *corev1.PersistentVo
 	}
 }
 
-func (i *CommandInitOption) etcdInitContainerCommand() []string {
-	etcdClusterConfig := ""
-	for v := int32(0); v < i.EtcdReplicas; v++ {
-		etcdClusterConfig += fmt.Sprintf("%s-%v=http://%s-%v.%s.%s.svc.%s:%v", etcdStatefulSetAndServiceName, v, etcdStatefulSetAndServiceName, v, etcdStatefulSetAndServiceName, i.Namespace, i.HostClusterDomain, etcdContainerServerPort) + ","
-	}
-
-	command := []string{
-		"sh",
-		"-c",
-		fmt.Sprintf(
-			`set -ex
-cat <<EOF | tee %s/%s
-name: ${%s}
-client-transport-security:
-  client-cert-auth: true
-  trusted-ca-file: %s/%s.crt
-  key-file: %s/%s.key
-  cert-file: %s/%s.crt
-peer-transport-security:
-  client-cert-auth: false
-  trusted-ca-file: %s/%s.crt
-  key-file: %s/%s.key
-  cert-file: %s/%s.crt
-initial-cluster-state: new
-initial-cluster-token: etcd-cluster
-initial-cluster: %s
-listen-peer-urls: http://${%s}:%v
-listen-client-urls: https://${%s}:%v,http://127.0.0.1:%v
-initial-advertise-peer-urls: http://${%s}:%v
-advertise-client-urls: https://${%s}.%s.%s.svc.%s:%v
-data-dir: %s
-cipher-suites: %s
-
-`,
-			etcdContainerConfigDataMountPath, etcdConfigName,
-			etcdEnvPodName,
-			karmadaCertsVolumeMountPath, options.EtcdCaCertAndKeyName,
-			karmadaCertsVolumeMountPath, options.EtcdServerCertAndKeyName,
-			karmadaCertsVolumeMountPath, options.EtcdServerCertAndKeyName,
-			karmadaCertsVolumeMountPath, options.EtcdCaCertAndKeyName,
-			karmadaCertsVolumeMountPath, options.EtcdServerCertAndKeyName,
-			karmadaCertsVolumeMountPath, options.EtcdServerCertAndKeyName,
-			strings.TrimRight(etcdClusterConfig, ","),
-			etcdEnvPodIP, etcdContainerServerPort,
-			etcdEnvPodIP, etcdContainerClientPort, etcdContainerClientPort,
-			etcdEnvPodIP, etcdContainerServerPort,
-			etcdEnvPodName, etcdStatefulSetAndServiceName,
-			i.Namespace, i.HostClusterDomain,
-			etcdContainerClientPort,
-			etcdContainerDataVolumeMountPath,
-			etcdCipherSuites,
-		),
-	}
-
-	return command
-}
-
 func (i *CommandInitOption) makeETCDStatefulSet() *appsv1.StatefulSet {
 	Volumes, persistentVolumeClaim := i.etcdVolume()
 
@@ -258,12 +199,9 @@ func (i *CommandInitOption) makeETCDStatefulSet() *appsv1.StatefulSet {
 		AutomountServiceAccountToken: ptr.To[bool](false),
 		Containers: []corev1.Container{
 			{
-				Name:  etcdStatefulSetAndServiceName,
-				Image: i.etcdImage(),
-				Command: []string{
-					"/usr/local/bin/etcd",
-					fmt.Sprintf("--config-file=%s/%s", etcdContainerConfigDataMountPath, etcdConfigName),
-				},
+				Name:    etcdStatefulSetAndServiceName,
+				Image:   i.etcdImage(),
+				Command: i.EtcdContainerCmd,
 				Ports: []corev1.ContainerPort{
 					{
 						Name:          etcdContainerClientPortName,
@@ -295,6 +233,24 @@ func (i *CommandInitOption) makeETCDStatefulSet() *appsv1.StatefulSet {
 				},
 				LivenessProbe: livenesProbe,
 				//ReadinessProbe: readinesProbe,
+				Env: []corev1.EnvVar{
+					{
+						Name: etcdEnvPodName,
+						ValueFrom: &corev1.EnvVarSource{
+							FieldRef: &corev1.ObjectFieldSelector{
+								FieldPath: "metadata.name",
+							},
+						},
+					},
+					{
+						Name: etcdEnvPodIP,
+						ValueFrom: &corev1.EnvVarSource{
+							FieldRef: &corev1.ObjectFieldSelector{
+								FieldPath: "status.podIP",
+							},
+						},
+					},
+				},
 			},
 		},
 		Volumes: *Volumes,
@@ -308,40 +264,6 @@ func (i *CommandInitOption) makeETCDStatefulSet() *appsv1.StatefulSet {
 		}
 	}
 
-	// InitContainers
-	podSpec.InitContainers = []corev1.Container{
-		{
-			Name:    "etcd-init-conf",
-			Image:   i.etcdInitImage(),
-			Command: i.etcdInitContainerCommand(),
-			VolumeMounts: []corev1.VolumeMount{
-				{
-					Name:      etcdContainerConfigVolumeMountName,
-					ReadOnly:  false,
-					MountPath: etcdContainerConfigDataMountPath,
-				},
-			},
-			Env: []corev1.EnvVar{
-				{
-					Name: etcdEnvPodName,
-					ValueFrom: &corev1.EnvVarSource{
-						FieldRef: &corev1.ObjectFieldSelector{
-							FieldPath: "metadata.name",
-						},
-					},
-				},
-				{
-					Name: etcdEnvPodIP,
-					ValueFrom: &corev1.EnvVarSource{
-						FieldRef: &corev1.ObjectFieldSelector{
-							FieldPath: "status.podIP",
-						},
-					},
-				},
-			},
-		},
-	}
-
 	// PodTemplateSpec
 	podTemplateSpec := corev1.PodTemplateSpec{
 		ObjectMeta: metav1.ObjectMeta{
@@ -376,7 +298,5 @@ func (i *CommandInitOption) makeETCDStatefulSet() *appsv1.StatefulSet {
 // They are obtained by the return value of the function CipherSuites() under the go/src/crypto/tls/cipher_suites.go package.
 // Consistent with the Preferred values of k8s’s default cipher suites.
 func genEtcdCipherSuites() string {
-	cipherSuites := strings.Join(flag.PreferredTLSCipherNames(), "\",\"")
-	cipherSuites = "[\"" + cipherSuites + "\"]"
-	return cipherSuites
+	return strings.Join(flag.PreferredTLSCipherNames(), ",")
 }
diff --git a/pkg/karmadactl/cmdinit/utils/command.go b/pkg/karmadactl/cmdinit/utils/command.go
new file mode 100644
index 000000000..02db29022
--- /dev/null
+++ b/pkg/karmadactl/cmdinit/utils/command.go
@@ -0,0 +1,136 @@
+/*
+Copyright 2025 The Karmada Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package utils
+
+import (
+	"fmt"
+	"regexp"
+	"sort"
+	"strings"
+
+	"k8s.io/klog/v2"
+)
+
+// ValidateExtraArgs preProcessArgs and  validateArgs
+func ValidateExtraArgs(extraArgs []string) ([]string, error) {
+	// Parameter preprocessing
+	preprocessArgs, err := preProcessArgs(extraArgs)
+	if err != nil {
+		return nil, err
+	}
+	// Verification parameters
+	args, err := validateArgs(preprocessArgs)
+	if err != nil {
+		klog.Errorf("%v", err)
+		return nil, err
+	}
+	return args, nil
+}
+
+// preProcessArgs
+// Because it is received as user parameters using pflag.StringSliceVar,
+// when a user inputs: --xxx-extra-args="--k1=v1,v2,v3",
+// the received parameter list is: [--k1=v1 v2 v3].
+// Therefore, it needs to be preprocessed to convert it into [--key=v1,v2,v3].
+func preProcessArgs(args []string) ([]string, error) {
+	if len(args) == 0 {
+		return args, nil
+	}
+
+	// Pre-create a slice with capacity.
+	merged := make([]string, 0, len(args))
+	var last string
+
+	for _, raw := range args {
+		arg := strings.TrimSpace(raw)
+		if arg != raw {
+			return nil, fmt.Errorf("argument %q contains leading/trailing whitespace", raw)
+		}
+
+		if strings.HasPrefix(arg, "--") {
+			if last != "" {
+				merged = append(merged, last)
+			}
+			last = arg
+		} else {
+			if last == "" {
+				// This indicates that this is the first argument passed in from the command line,
+				// but it does not have the prefix "--".
+				return nil, fmt.Errorf("argument %q is invalid: no preceding --key found", arg)
+			}
+			last += "," + arg
+		}
+	}
+
+	if last != "" {
+		merged = append(merged, last)
+	}
+	return merged, nil
+}
+
+// Regular expression validation of user-provided parameters.
+// format: --key=value or --key (e.g., --enable-pprof)
+func validateArgs(args []string) ([]string, error) {
+	argPattern := regexp.MustCompile(`^--[a-zA-Z][a-zA-Z0-9_-]*(=.*)?$`)
+	for _, arg := range args {
+		if !argPattern.MatchString(arg) {
+			return nil, fmt.Errorf("invalid argument: %s", arg)
+		}
+	}
+	return args, nil
+}
+
+// MergeCommandArgs merges defaultArgs with extraArgs, with extraArgs overriding defaults.
+// It assumes extraArgs are already pre-processed and validated.
+func MergeCommandArgs(defaultArgs, extraArgs []string) []string {
+	extraArgsMap := make(map[string]string, len(extraArgs))
+	for _, arg := range extraArgs {
+		// Assuming extraArgs are already validated to start with "--" and be in --key=value or --key format
+		// SplitN with limit 2 handles cases like --key=value1=value2 correctly, taking only the first '=' as delimiter
+		parts := strings.SplitN(arg, "=", 2)
+		key := parts[0]
+		extraArgsMap[key] = arg
+	}
+	finalArgs := make([]string, 0, len(defaultArgs)+len(extraArgs))
+
+	// First, add the command name if defaultArgs is not empty.
+	if len(defaultArgs) > 0 {
+		finalArgs = append(finalArgs, defaultArgs[0])
+	}
+
+	// Add default arguments, skipping any that are overridden by extraArgs.
+	if len(defaultArgs) > 1 {
+		for _, arg := range defaultArgs[1:] {
+			parts := strings.SplitN(arg, "=", 2)
+			key := parts[0]
+			if _, ok := extraArgsMap[key]; !ok {
+				finalArgs = append(finalArgs, arg)
+			}
+		}
+	}
+
+	// Add all extra arguments. To ensure deterministic output for tests, sort them.
+	sortedExtraArgs := make([]string, 0, len(extraArgs))
+	for _, arg := range extraArgsMap {
+		sortedExtraArgs = append(sortedExtraArgs, arg)
+	}
+
+	sort.Strings(sortedExtraArgs)
+	finalArgs = append(finalArgs, sortedExtraArgs...)
+
+	return finalArgs
+}
diff --git a/pkg/metricsadapter/provider/resourcemetrics.go b/pkg/metricsadapter/provider/resourcemetrics.go
index 89a547c1a..8fa9e956e 100755
--- a/pkg/metricsadapter/provider/resourcemetrics.go
+++ b/pkg/metricsadapter/provider/resourcemetrics.go
@@ -259,7 +259,7 @@ func (r *ResourceMetricsProvider) queryPodMetricsBySelector(selector, namespace
 // queryNodeMetricsByName queries metrics by node name from target clusters
 func (r *ResourceMetricsProvider) queryNodeMetricsByName(name string) ([]metrics.NodeMetrics, error) {
 	resourceQueryFunc := func(sci typedmanager.SingleClusterInformerManager, _ string) error {
-		nodeInterface, err := sci.Lister(PodsGVR)
+		nodeInterface, err := sci.Lister(NodesGVR)
 		if err != nil {
 			return err
 		}
diff --git a/pkg/resourceinterpreter/default/native/dependencies.go b/pkg/resourceinterpreter/default/native/dependencies.go
index 0e6095059..0c8353701 100644
--- a/pkg/resourceinterpreter/default/native/dependencies.go
+++ b/pkg/resourceinterpreter/default/native/dependencies.go
@@ -42,6 +42,7 @@ type dependenciesInterpreter func(object *unstructured.Unstructured) ([]configv1
 func getAllDefaultDependenciesInterpreter() map[schema.GroupVersionKind]dependenciesInterpreter {
 	s := make(map[schema.GroupVersionKind]dependenciesInterpreter)
 	s[appsv1.SchemeGroupVersion.WithKind(util.DeploymentKind)] = getDeploymentDependencies
+	s[appsv1.SchemeGroupVersion.WithKind(util.ReplicaSetKind)] = getReplicaSetDependencies
 	s[batchv1.SchemeGroupVersion.WithKind(util.JobKind)] = getJobDependencies
 	s[batchv1.SchemeGroupVersion.WithKind(util.CronJobKind)] = getCronJobDependencies
 	s[corev1.SchemeGroupVersion.WithKind(util.PodKind)] = getPodDependencies
@@ -66,6 +67,20 @@ func getDeploymentDependencies(object *unstructured.Unstructured) ([]configv1alp
 	return helper.GetDependenciesFromPodTemplate(podObj)
 }
 
+func getReplicaSetDependencies(object *unstructured.Unstructured) ([]configv1alpha1.DependentObjectReference, error) {
+	replicaSetObj := &appsv1.ReplicaSet{}
+	if err := helper.ConvertToTypedObject(object, replicaSetObj); err != nil {
+		return nil, fmt.Errorf("failed to convert ReplicaSet from unstructured object: %v", err)
+	}
+
+	podObj, err := lifted.GetPodFromTemplate(&replicaSetObj.Spec.Template, replicaSetObj, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return helper.GetDependenciesFromPodTemplate(podObj)
+}
+
 func getJobDependencies(object *unstructured.Unstructured) ([]configv1alpha1.DependentObjectReference, error) {
 	jobObj := &batchv1.Job{}
 	err := helper.ConvertToTypedObject(object, jobObj)
diff --git a/pkg/resourceinterpreter/default/native/reflectstatus.go b/pkg/resourceinterpreter/default/native/reflectstatus.go
index cb9a29927..64964f5b2 100644
--- a/pkg/resourceinterpreter/default/native/reflectstatus.go
+++ b/pkg/resourceinterpreter/default/native/reflectstatus.go
@@ -41,6 +41,7 @@ type reflectStatusInterpreter func(object *unstructured.Unstructured) (*runtime.
 func getAllDefaultReflectStatusInterpreter() map[schema.GroupVersionKind]reflectStatusInterpreter {
 	s := make(map[schema.GroupVersionKind]reflectStatusInterpreter)
 	s[appsv1.SchemeGroupVersion.WithKind(util.DeploymentKind)] = reflectDeploymentStatus
+	s[appsv1.SchemeGroupVersion.WithKind(util.ReplicaSetKind)] = reflectReplicaSetStatus
 	s[corev1.SchemeGroupVersion.WithKind(util.ServiceKind)] = reflectServiceStatus
 	s[networkingv1.SchemeGroupVersion.WithKind(util.IngressKind)] = reflectIngressStatus
 	s[batchv1.SchemeGroupVersion.WithKind(util.JobKind)] = reflectJobStatus
@@ -105,6 +106,58 @@ func reflectDeploymentStatus(object *unstructured.Unstructured) (*runtime.RawExt
 	return grabStatusRaw, nil
 }
 
+func reflectReplicaSetStatus(object *unstructured.Unstructured) (*runtime.RawExtension, error) {
+	statusMap, exist, err := unstructured.NestedMap(object.Object, "status")
+	if err != nil {
+		klog.Errorf("Failed to get status field from %s(%s/%s), error: %v",
+			object.GetKind(), object.GetNamespace(), object.GetName(), err)
+		return nil, err
+	}
+	if !exist {
+		klog.Errorf("Failed to grab status from %s(%s/%s) which should have status field.",
+			object.GetKind(), object.GetNamespace(), object.GetName())
+		return nil, nil
+	}
+
+	replicaSetStatus := &appsv1.ReplicaSetStatus{}
+	if err = helper.ConvertToTypedObject(statusMap, replicaSetStatus); err != nil {
+		return nil, fmt.Errorf("failed to convert ReplicaSetStatus from map[string]interface{}: %v", err)
+	}
+
+	resourceTemplateGenerationInt := int64(0)
+	resourceTemplateGenerationStr := util.GetAnnotationValue(object.GetAnnotations(), v1alpha2.ResourceTemplateGenerationAnnotationKey)
+	err = runtime.Convert_string_To_int64(&resourceTemplateGenerationStr, &resourceTemplateGenerationInt, nil)
+	if err != nil {
+		klog.Errorf("Failed to parse ReplicaSet(%s/%s) generation from annotation(%s:%s): %v", object.GetNamespace(), object.GetName(), v1alpha2.ResourceTemplateGenerationAnnotationKey, resourceTemplateGenerationStr, err)
+		return nil, err
+	}
+
+	grabStatus := &WrappedReplicaSetStatus{
+		FederatedGeneration: FederatedGeneration{
+			Generation:                 object.GetGeneration(),
+			ResourceTemplateGeneration: resourceTemplateGenerationInt,
+		},
+		ReplicaSetStatus: appsv1.ReplicaSetStatus{
+			Replicas:           replicaSetStatus.Replicas,
+			ReadyReplicas:      replicaSetStatus.ReadyReplicas,
+			AvailableReplicas:  replicaSetStatus.AvailableReplicas,
+			ObservedGeneration: replicaSetStatus.ObservedGeneration,
+		},
+	}
+
+	grabStatusRaw, err := helper.BuildStatusRawExtension(grabStatus)
+	if err != nil {
+		return nil, err
+	}
+
+	// if status is empty struct, it actually means status haven't been collected from member cluster.
+	if bytes.Equal(grabStatusRaw.Raw, []byte("{}")) {
+		return nil, nil
+	}
+
+	return grabStatusRaw, nil
+}
+
 func reflectServiceStatus(object *unstructured.Unstructured) (*runtime.RawExtension, error) {
 	serviceType, exist, err := unstructured.NestedString(object.Object, "spec", "type")
 	if err != nil {
diff --git a/pkg/resourceinterpreter/default/native/replica.go b/pkg/resourceinterpreter/default/native/replica.go
index 53b2a6003..aa3e0a420 100644
--- a/pkg/resourceinterpreter/default/native/replica.go
+++ b/pkg/resourceinterpreter/default/native/replica.go
@@ -36,6 +36,7 @@ type replicaInterpreter func(object *unstructured.Unstructured) (int32, *workv1a
 func getAllDefaultReplicaInterpreter() map[schema.GroupVersionKind]replicaInterpreter {
 	s := make(map[schema.GroupVersionKind]replicaInterpreter)
 	s[appsv1.SchemeGroupVersion.WithKind(util.DeploymentKind)] = deployReplica
+	s[appsv1.SchemeGroupVersion.WithKind(util.ReplicaSetKind)] = replicaSetReplica
 	s[appsv1.SchemeGroupVersion.WithKind(util.StatefulSetKind)] = statefulSetReplica
 	s[batchv1.SchemeGroupVersion.WithKind(util.JobKind)] = jobReplica
 	s[corev1.SchemeGroupVersion.WithKind(util.PodKind)] = podReplica
@@ -58,6 +59,22 @@ func deployReplica(object *unstructured.Unstructured) (int32, *workv1alpha2.Repl
 	return replica, requirement, nil
 }
 
+func replicaSetReplica(object *unstructured.Unstructured) (int32, *workv1alpha2.ReplicaRequirements, error) {
+	rs := &appsv1.ReplicaSet{}
+	if err := helper.ConvertToTypedObject(object, rs); err != nil {
+		klog.Errorf("Failed to convert object(%s), err %v", object.GroupVersionKind().String(), err)
+		return 0, nil, err
+	}
+
+	var replica int32
+	if rs.Spec.Replicas != nil {
+		replica = *rs.Spec.Replicas
+	}
+	requirement := helper.GenerateReplicaRequirements(&rs.Spec.Template)
+
+	return replica, requirement, nil
+}
+
 func statefulSetReplica(object *unstructured.Unstructured) (int32, *workv1alpha2.ReplicaRequirements, error) {
 	sts := &appsv1.StatefulSet{}
 	if err := helper.ConvertToTypedObject(object, sts); err != nil {
diff --git a/pkg/resourceinterpreter/default/native/revisereplica.go b/pkg/resourceinterpreter/default/native/revisereplica.go
index df4f54306..e73391a5f 100644
--- a/pkg/resourceinterpreter/default/native/revisereplica.go
+++ b/pkg/resourceinterpreter/default/native/revisereplica.go
@@ -31,6 +31,7 @@ type reviseReplicaInterpreter func(object *unstructured.Unstructured, replica in
 func getAllDefaultReviseReplicaInterpreter() map[schema.GroupVersionKind]reviseReplicaInterpreter {
 	s := make(map[schema.GroupVersionKind]reviseReplicaInterpreter)
 	s[appsv1.SchemeGroupVersion.WithKind(util.DeploymentKind)] = reviseDeploymentReplica
+	s[appsv1.SchemeGroupVersion.WithKind(util.ReplicaSetKind)] = reviseReplicaSetReplica
 	s[appsv1.SchemeGroupVersion.WithKind(util.StatefulSetKind)] = reviseStatefulSetReplica
 	s[batchv1.SchemeGroupVersion.WithKind(util.JobKind)] = reviseJobReplica
 	return s
@@ -43,6 +44,13 @@ func reviseDeploymentReplica(object *unstructured.Unstructured, replica int64) (
 	return object, nil
 }
 
+func reviseReplicaSetReplica(object *unstructured.Unstructured, replica int64) (*unstructured.Unstructured, error) {
+	if err := helper.ApplyReplica(object, replica, util.ReplicasField); err != nil {
+		return nil, err
+	}
+	return object, nil
+}
+
 func reviseStatefulSetReplica(object *unstructured.Unstructured, replica int64) (*unstructured.Unstructured, error) {
 	if err := helper.ApplyReplica(object, replica, util.ReplicasField); err != nil {
 		return nil, err
diff --git a/pkg/resourceinterpreter/default/native/status_type.go b/pkg/resourceinterpreter/default/native/status_type.go
index ac014bc0b..514d3d800 100644
--- a/pkg/resourceinterpreter/default/native/status_type.go
+++ b/pkg/resourceinterpreter/default/native/status_type.go
@@ -40,6 +40,12 @@ type WrappedDaemonSetStatus struct {
 	appsv1.DaemonSetStatus `json:",inline"`
 }
 
+// WrappedReplicaSetStatus is a wrapper for appsv1.ReplicaSetStatus.
+type WrappedReplicaSetStatus struct {
+	FederatedGeneration     `json:",inline"`
+	appsv1.ReplicaSetStatus `json:",inline"`
+}
+
 // WrappedStatefulSetStatus is a wrapper for appsv1.StatefulSetStatus.
 type WrappedStatefulSetStatus struct {
 	FederatedGeneration      `json:",inline"`
diff --git a/pkg/util/names/names.go b/pkg/util/names/names.go
index eb3b64907..1e08da954 100644
--- a/pkg/util/names/names.go
+++ b/pkg/util/names/names.go
@@ -68,6 +68,12 @@ const (
 
 	// KubeControllerManagerComponentName is the name of the Kube Controller Manager component.
 	KubeControllerManagerComponentName = "kube-controller-manager"
+
+	// KarmadaEtcdComponentName is the name of the Karmada Etcd component.
+	KarmadaEtcdComponentName = "karmada-etcd"
+
+	// KarmadaAPIServerComponentName is the name of the Karmada API Server component.
+	KarmadaAPIServerComponentName = "karmada-apiserver"
 )
 
 // ExecutionSpacePrefix is the prefix of execution space



Test patch:
diff --git a/pkg/karmadactl/cmdinit/kubernetes/deployments_test.go b/pkg/karmadactl/cmdinit/kubernetes/deployments_test.go
index 28aad67ba..97670a178 100644
--- a/pkg/karmadactl/cmdinit/kubernetes/deployments_test.go
+++ b/pkg/karmadactl/cmdinit/kubernetes/deployments_test.go
@@ -29,9 +29,9 @@ func TestCommandInitOption_etcdServers(t *testing.T) {
 
 func TestCommandInitOption_karmadaAPIServerContainerCommand(t *testing.T) {
 	cmdOpt := CommandInitOption{EtcdReplicas: 1, Namespace: "karmada"}
-	flags := cmdOpt.karmadaAPIServerContainerCommand()
+	flags := cmdOpt.defaultKarmadaAPIServerContainerCommand()
 	if len(flags) == 0 {
-		t.Errorf("CommandInitOption.karmadaAPIServerContainerCommand() returns empty")
+		t.Errorf("CommandInitOption.defaultKarmadaAPIServerContainerCommand() returns empty")
 	}
 }
 
diff --git a/pkg/karmadactl/cmdinit/kubernetes/statefulset_test.go b/pkg/karmadactl/cmdinit/kubernetes/statefulset_test.go
index 7b9b42237..5d48aa567 100644
--- a/pkg/karmadactl/cmdinit/kubernetes/statefulset_test.go
+++ b/pkg/karmadactl/cmdinit/kubernetes/statefulset_test.go
@@ -69,13 +69,6 @@ func TestCommandInitIOption_etcdVolume(t *testing.T) {
 	}
 }
 
-func TestCommandInitIOption_etcdInitContainerCommand(t *testing.T) {
-	opt := CommandInitOption{Namespace: "karmada", EtcdReplicas: 1}
-	if got := opt.etcdInitContainerCommand(); len(got) == 0 {
-		t.Errorf("CommandInitOption.etcdInitContainerCommand() returns empty")
-	}
-}
-
 func TestCommandInitIOption_makeETCDStatefulSet(t *testing.T) {
 	tests := []struct {
 		name          string
diff --git a/pkg/karmadactl/cmdinit/utils/command_test.go b/pkg/karmadactl/cmdinit/utils/command_test.go
new file mode 100644
index 000000000..9fc45c5bf
--- /dev/null
+++ b/pkg/karmadactl/cmdinit/utils/command_test.go
@@ -0,0 +1,458 @@
+/*
+Copyright 2025 The Karmada Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package utils
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+var (
+	defaultArgs = []string{
+		"test",
+		"--v=6",                          // --key=value
+		"--runtime-config=",              // --key=
+		"--authorization-mode=Node,RBAC", // --key=v1,v2
+	}
+)
+
+type componentCommandCase struct {
+	name      string
+	extraArgs []string
+	finalArgs []string
+	err       error
+}
+
+// User normal input
+var commonCases = []componentCommandCase{
+	// 1. --key=value format (replace existing parameters)
+	{
+		name:      "replace existing key=value",
+		extraArgs: []string{"--v=2"},
+		finalArgs: []string{
+			"test",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+			"--v=2",
+		},
+		err: nil,
+	},
+
+	// 2. --key= format (replace existing parameters with empty values)
+	{
+		name:      "replace with empty value",
+		extraArgs: []string{"--runtime-config="},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--authorization-mode=Node,RBAC",
+			"--runtime-config=",
+		},
+		err: nil,
+	},
+
+	// 3. --key format (Boolean flag, new parameter)
+	{
+		name:      "add boolean flag",
+		extraArgs: []string{"--enable-pprof"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+			"--enable-pprof",
+		},
+		err: nil,
+	},
+
+	// 4. --key=v1,v2 format (merging multiple values through preprocessing)
+	{
+		name:      "merge multiple values",
+		extraArgs: []string{"--new-option=value1", "value2", "value3"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+			"--new-option=value1,value2,value3",
+		},
+		err: nil,
+	},
+
+	// 5. Mixing multiple formats
+	{
+		name: "mixed formats",
+		extraArgs: []string{
+			"--v=4",               // Replace
+			"--enable-audit",      // Add a Boolean flag.
+			"--ports=8080", "443", // Add multiple values.
+		},
+		finalArgs: []string{
+			"test",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+			"--enable-audit",
+			"--ports=8080,443",
+			"--v=4",
+		},
+		err: nil,
+	},
+
+	// 6. Replace multiple existing parameters
+	{
+		name: "replace multiple existing",
+		extraArgs: []string{
+			"--v=8",
+			"--authorization-mode=RBAC",
+		},
+		finalArgs: []string{
+			"test",
+			"--runtime-config=",
+			"--authorization-mode=RBAC",
+			"--v=8",
+		},
+		err: nil,
+	},
+
+	// 7. Empty input
+	{
+		name:      "empty extra args",
+		extraArgs: []string{},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+		},
+		err: nil,
+	},
+	// 8. Includes equal sign
+	{
+		name:      "equals in key name",
+		extraArgs: []string{"--key=name=value"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+			"--key=name=value", // This is legal because SplitN(arg, "=", 2) only splits at the first "=".
+		},
+		err: nil,
+	},
+	{
+		name:      "multiple equals signs",
+		extraArgs: []string{"--config=key1=value1=extra"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+			"--config=key1=value1=extra", // It's valid because it's only split at the first = sign.
+		},
+		err: nil,
+	},
+	// 9. Underscore
+	{
+		name:      "key with numbers and special chars",
+		extraArgs: []string{"--key123_test_value=123"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+			"--key123_test_value=123",
+		},
+		err: nil,
+	},
+}
+
+// User input error.
+var errCase = []componentCommandCase{
+	// 1. Missing the "--" prefix.
+	{
+		name:      "missing -- prefix",
+		extraArgs: []string{"v=2"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+		},
+		err: errors.New("want error"),
+	},
+	{
+		name:      "single dash prefix",
+		extraArgs: []string{"-v=2"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+		},
+		err: errors.New("want error"),
+	},
+
+	// 2. Chinese comma issue
+	{
+		name:      "chinese comma in value",
+		extraArgs: []string{"--ports=8080，443"}, // Chinese comma
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+			"--ports=8080，443",
+		},
+		err: nil,
+	},
+	{
+		// --test-extra-args="--modes=read,write，execute"
+		name:      "mixed comma types",
+		extraArgs: []string{"--modes=read", "write，execute"}, // Mixed Chinese and English comma
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+			"--modes=read,write，execute",
+		},
+		err: nil,
+	},
+
+	// 3. Special characters and format errors
+	{
+		name:      "space in key name", // In this situation, it will return the default parameters directly.
+		extraArgs: []string{"--my key=value"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+		},
+		err: errors.New("want error"),
+	},
+
+	// 4. Null values and special cases
+	{
+		name:      "empty argument",
+		extraArgs: []string{""},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+		},
+		err: errors.New("want error"), // This is because the first parameter is an empty string, which will return an error when checking the prefix.
+	},
+	{
+		name:      "only dashes",
+		extraArgs: []string{"--"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+		},
+		err: errors.New("want error"),
+	},
+
+	// 5. Illegal key naming
+	{
+		name:      "key starts with number",
+		extraArgs: []string{"--123key=value"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+		},
+		err: errors.New("want error"),
+	},
+	{
+		name:      "key with special characters",
+		extraArgs: []string{"--key@host=value"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+		}, // The "@" symbol is not allowed.
+		err: errors.New("want error"),
+	},
+
+	// 6. Unicode and encoding issues
+	{
+		name:      "unicode characters in key",
+		extraArgs: []string{"--配置=value"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+		},
+		err: errors.New("want error"),
+	},
+	{
+		name:      "emoji in value",
+		extraArgs: []string{"--status=running😊"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+			"--status=running😊", // Special characters in values are usually allowed.
+		},
+		err: nil,
+	},
+
+	// 7. Isolated value (without a corresponding key)
+	{
+		name:      "orphaned value at start",
+		extraArgs: []string{"orphaned", "--key=value"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC", // preProcessArgs will return default args.
+		},
+		err: errors.New("want error"),
+	},
+	{
+		name:      "multiple orphaned values",
+		extraArgs: []string{"value1", "value2", "--key=value"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC", // preProcessArgs will return default args.
+		},
+		err: errors.New("want error"),
+	},
+
+	// 8. Space and tab issues
+	{
+		name:      "leading/trailing spaces",
+		extraArgs: []string{" --key=value "},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+		},
+		err: errors.New("want error"),
+	},
+	{
+		name:      "tab characters",
+		extraArgs: []string{"--key=value\t"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+		},
+		err: errors.New("want error"),
+	},
+
+	// 9. Repeated equal signs
+	{
+		name:      "double equals",
+		extraArgs: []string{"--key==value"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+			"--key==value", // The first letter of this value is "=".
+		},
+		err: nil,
+	},
+
+	// 10. Extreme Length Test
+	{
+		name:      "very long key name",
+		extraArgs: []string{"--" + strings.Repeat("a", 1000) + "=value"},
+		finalArgs: []string{
+			"test",
+			"--v=6",
+			"--runtime-config=",
+			"--authorization-mode=Node,RBAC",
+			"--" + strings.Repeat("a", 1000) + "=value",
+		},
+		err: nil,
+	},
+}
+
+// KarmadaComponentCommand Integration test ValidateExtraArgs and MergeCommandArgs
+// Note: this function is only used in tests
+func KarmadaComponentCommand(defaultArgs, extraArgs []string) ([]string, error) {
+	// Return directly without parameters.
+	if len(extraArgs) == 0 {
+		return defaultArgs, nil
+	}
+
+	// Validate Parameters
+	args, err := ValidateExtraArgs(extraArgs)
+	if err != nil {
+		return defaultArgs, err
+	}
+
+	// merge Parameters
+	return MergeCommandArgs(defaultArgs, args), nil
+}
+
+// Abstract a function that runs multiple test cases.
+func testCase(cases []componentCommandCase, t *testing.T) {
+	for _, c := range cases {
+		got, err := KarmadaComponentCommand(defaultArgs, c.extraArgs)
+		if err != nil {
+			if c.err == nil {
+				t.Errorf("test case [%s] failed, want: %v, got: %v", c.name, c.err, err)
+			}
+		} else {
+			if c.err != nil {
+				t.Errorf("test case [%s] failed, want: %v, got: %v", c.name, c.err, err)
+			}
+		}
+		if !reflect.DeepEqual(got, c.finalArgs) {
+			t.Errorf("test case [%s] failed, want: %v, got: %v", c.name, c.finalArgs, got)
+		}
+	}
+}
+
+// Define a test function for each group.
+func testCommonCase(t *testing.T) {
+	testCase(commonCases, t)
+}
+
+func testErrCase(t *testing.T) {
+	testCase(errCase, t)
+}
+
+// Test function
+func TestKarmadaComponentCommand(t *testing.T) {
+	t.Run("CommonCase", testCommonCase)
+	t.Run("ErrCase", testErrCase)
+}
+
+// Benchmark test
+func BenchmarkKarmadaComponentCommand(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_, _ = KarmadaComponentCommand(defaultArgs, commonCases[0].extraArgs)
+	}
+}
diff --git a/pkg/resourceinterpreter/default/native/aggregatestatus.go b/pkg/resourceinterpreter/default/native/aggregatestatus.go
index 48d4ee877..415bf03aa 100644
--- a/pkg/resourceinterpreter/default/native/aggregatestatus.go
+++ b/pkg/resourceinterpreter/default/native/aggregatestatus.go
@@ -43,6 +43,7 @@ type aggregateStatusInterpreter func(object *unstructured.Unstructured, aggregat
 func getAllDefaultAggregateStatusInterpreter() map[schema.GroupVersionKind]aggregateStatusInterpreter {
 	s := make(map[schema.GroupVersionKind]aggregateStatusInterpreter)
 	s[appsv1.SchemeGroupVersion.WithKind(util.DeploymentKind)] = aggregateDeploymentStatus
+	s[appsv1.SchemeGroupVersion.WithKind(util.ReplicaSetKind)] = aggregateReplicaSetStatus
 	s[corev1.SchemeGroupVersion.WithKind(util.ServiceKind)] = aggregateServiceStatus
 	s[networkingv1.SchemeGroupVersion.WithKind(util.IngressKind)] = aggregateIngressStatus
 	s[batchv1.SchemeGroupVersion.WithKind(util.JobKind)] = aggregateJobStatus
@@ -120,6 +121,63 @@ func aggregateDeploymentStatus(object *unstructured.Unstructured, aggregatedStat
 	return helper.ToUnstructured(deploy)
 }
 
+func aggregateReplicaSetStatus(object *unstructured.Unstructured, aggregatedStatusItems []workv1alpha2.AggregatedStatusItem) (*unstructured.Unstructured, error) {
+	rs := &appsv1.ReplicaSet{}
+	err := helper.ConvertToTypedObject(object, rs)
+	if err != nil {
+		return nil, err
+	}
+
+	oldStatus := &rs.Status
+	newStatus := &appsv1.ReplicaSetStatus{}
+	observedLatestResourceTemplateGenerationCount := 0
+	for _, item := range aggregatedStatusItems {
+		if item.Status == nil {
+			continue
+		}
+		member := &WrappedReplicaSetStatus{}
+		if err = json.Unmarshal(item.Status.Raw, member); err != nil {
+			return nil, err
+		}
+		klog.V(3).Infof("Grab replicaset(%s/%s) status from cluster(%s), replicas: %d, ready: %d, available: %d",
+			rs.Namespace, rs.Name, item.ClusterName, member.Replicas, member.ReadyReplicas, member.AvailableReplicas)
+
+		// `memberStatus.ObservedGeneration >= memberStatus.Generation` means the member's status corresponds the latest spec revision of the member replicaset.
+		// `memberStatus.ResourceTemplateGeneration >= rs.Generation` means the member replicaset has been aligned with the latest spec revision of federated replicaset.
+		// If both conditions are met, we consider the member's status corresponds the latest spec revision of federated replicaset.
+		if member.ObservedGeneration >= member.Generation &&
+			member.ResourceTemplateGeneration >= rs.Generation {
+			observedLatestResourceTemplateGenerationCount++
+		}
+
+		newStatus.Replicas += member.Replicas
+		newStatus.ReadyReplicas += member.ReadyReplicas
+		newStatus.AvailableReplicas += member.AvailableReplicas
+	}
+
+	// The 'observedGeneration' is mainly used by GitOps tools(like 'Argo CD') to assess the health status.
+	// For more details, please refer to https://argo-cd.readthedocs.io/en/stable/operator-manual/health/.
+	newStatus.ObservedGeneration = oldStatus.ObservedGeneration
+	if observedLatestResourceTemplateGenerationCount == len(aggregatedStatusItems) {
+		newStatus.ObservedGeneration = rs.Generation
+	}
+
+	if oldStatus.ObservedGeneration == newStatus.ObservedGeneration &&
+		oldStatus.Replicas == newStatus.Replicas &&
+		oldStatus.ReadyReplicas == newStatus.ReadyReplicas &&
+		oldStatus.AvailableReplicas == newStatus.AvailableReplicas {
+		klog.V(3).Infof("Ignore update replicaset(%s/%s) status as up to date", rs.Namespace, rs.Name)
+		return object, nil
+	}
+
+	oldStatus.ObservedGeneration = newStatus.ObservedGeneration
+	oldStatus.Replicas = newStatus.Replicas
+	oldStatus.ReadyReplicas = newStatus.ReadyReplicas
+	oldStatus.AvailableReplicas = newStatus.AvailableReplicas
+
+	return helper.ToUnstructured(rs)
+}
+
 func aggregateServiceStatus(object *unstructured.Unstructured, aggregatedStatusItems []workv1alpha2.AggregatedStatusItem) (*unstructured.Unstructured, error) {
 	service := &corev1.Service{}
 	err := helper.ConvertToTypedObject(object, service)
diff --git a/pkg/resourceinterpreter/default/native/aggregatestatus_test.go b/pkg/resourceinterpreter/default/native/aggregatestatus_test.go
index 41ad664bf..e59334ae0 100644
--- a/pkg/resourceinterpreter/default/native/aggregatestatus_test.go
+++ b/pkg/resourceinterpreter/default/native/aggregatestatus_test.go
@@ -1294,6 +1294,7 @@ func Test_aggregateHorizontalPodAutoscalerStatus(t *testing.T) {
 func Test_getAllDefaultAggregateStatusInterpreter(t *testing.T) {
 	expectedKinds := []schema.GroupVersionKind{
 		{Group: "apps", Version: "v1", Kind: "Deployment"},
+		{Group: "apps", Version: "v1", Kind: "ReplicaSet"},
 		{Group: "apps", Version: "v1", Kind: "StatefulSet"},
 		{Group: "batch", Version: "v1", Kind: "Job"},
 		{Group: "", Version: "v1", Kind: "Pod"},
diff --git a/pkg/resourceinterpreter/default/native/dependencies_test.go b/pkg/resourceinterpreter/default/native/dependencies_test.go
index 94b6dc57c..523796382 100644
--- a/pkg/resourceinterpreter/default/native/dependencies_test.go
+++ b/pkg/resourceinterpreter/default/native/dependencies_test.go
@@ -311,6 +311,113 @@ func Test_getDeploymentDependencies(t *testing.T) {
 	}
 }
 
+func Test_getReplicaSetDependencies(t *testing.T) {
+	tests := []struct {
+		name    string
+		object  *unstructured.Unstructured
+		want    []configv1alpha1.DependentObjectReference
+		wantErr bool
+	}{
+		{
+			name: "replicaset without dependencies",
+			object: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "apps/v1",
+					"kind":       "ReplicaSet",
+					"metadata": map[string]interface{}{
+						"name":       "fake-replicaset",
+						"generation": 1,
+						"namespace":  namespace,
+					},
+					"spec": map[string]interface{}{
+						"replicas": 3,
+					},
+				},
+			},
+			want:    nil,
+			wantErr: false,
+		},
+		{
+			name: "replicaset with dependencies 1",
+			object: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "apps/v1",
+					"kind":       "ReplicaSet",
+					"metadata": map[string]interface{}{
+						"name":       "fake-replicaset",
+						"generation": 1,
+						"namespace":  namespace,
+					},
+					"spec": map[string]interface{}{
+						"replicas": 3,
+						"template": map[string]interface{}{
+							"spec": testPairs[0].podSpecsWithDependencies.Object,
+						},
+					},
+				},
+			},
+			want:    testPairs[0].dependentObjectReference,
+			wantErr: false,
+		},
+		{
+			name: "replicaset with dependencies 2",
+			object: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "apps/v1",
+					"kind":       "ReplicaSet",
+					"metadata": map[string]interface{}{
+						"name":      "fake-replicaset",
+						"namespace": namespace,
+					},
+					"spec": map[string]interface{}{
+						"replicas": 3,
+						"template": map[string]interface{}{
+							"spec": testPairs[1].podSpecsWithDependencies.Object,
+						},
+					},
+				},
+			},
+			want:    testPairs[1].dependentObjectReference,
+			wantErr: false,
+		},
+		{
+			name: "replicaset with dependencies 3",
+			object: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "apps/v1",
+					"kind":       "ReplicaSet",
+					"metadata": map[string]interface{}{
+						"name":      "fake-replicaset",
+						"namespace": namespace,
+					},
+					"spec": map[string]interface{}{
+						"replicas": 3,
+						"template": map[string]interface{}{
+							"spec": testPairs[2].podSpecsWithDependencies.Object,
+						},
+					},
+				},
+			},
+			want:    testPairs[2].dependentObjectReference,
+			wantErr: false,
+		},
+	}
+
+	for i := range tests {
+		tt := tests[i]
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			got, err := getReplicaSetDependencies(tt.object)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("getReplicaSetDependencies() err = %v, wantErr %v", err, tt.wantErr)
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("getReplicaSetDependencies() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
 func Test_getJobDependencies(t *testing.T) {
 	tests := []struct {
 		name    string
@@ -981,6 +1088,7 @@ func Test_getServiceImportDependencies(t *testing.T) {
 func Test_getAllDefaultDependenciesInterpreter(t *testing.T) {
 	expectedKinds := []schema.GroupVersionKind{
 		{Group: "apps", Version: "v1", Kind: "Deployment"},
+		{Group: "apps", Version: "v1", Kind: "ReplicaSet"},
 		{Group: "batch", Version: "v1", Kind: "Job"},
 		{Group: "batch", Version: "v1", Kind: "CronJob"},
 		{Group: "", Version: "v1", Kind: "Pod"},
diff --git a/pkg/resourceinterpreter/default/native/reflectstatus_test.go b/pkg/resourceinterpreter/default/native/reflectstatus_test.go
index 2d719e3c9..4004e7ea5 100644
--- a/pkg/resourceinterpreter/default/native/reflectstatus_test.go
+++ b/pkg/resourceinterpreter/default/native/reflectstatus_test.go
@@ -299,6 +299,11 @@ func Test_getAllDefaultReflectStatusInterpreter(t *testing.T) {
 			gvk:    appsv1.SchemeGroupVersion.WithKind(util.DeploymentKind),
 			wantFn: true,
 		},
+		{
+			name:   "ReplicaSet interpreter exists",
+			gvk:    appsv1.SchemeGroupVersion.WithKind(util.ReplicaSetKind),
+			wantFn: true,
+		},
 		{
 			name:   "Service interpreter exists",
 			gvk:    corev1.SchemeGroupVersion.WithKind(util.ServiceKind),
@@ -357,7 +362,7 @@ func Test_getAllDefaultReflectStatusInterpreter(t *testing.T) {
 	}
 
 	// Verify total number of interpreters
-	assert.Len(t, interpreters, 8, "unexpected number of interpreters")
+	assert.Len(t, interpreters, 9, "unexpected number of interpreters")
 
 	// Verify map is not nil
 	assert.NotNil(t, interpreters, "interpreters map should not be nil")
@@ -473,6 +478,114 @@ func Test_reflectDeploymentStatus(t *testing.T) {
 	}
 }
 
+func Test_reflectReplicaSetStatus(t *testing.T) {
+	validReplicaSet := &appsv1.ReplicaSet{
+		TypeMeta: metav1.TypeMeta{
+			Kind:       "ReplicaSet",
+			APIVersion: appsv1.SchemeGroupVersion.String(),
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			Name:       "test-replicaset",
+			Namespace:  "test-ns",
+			Generation: 2,
+			Annotations: map[string]string{
+				workv1alpha2.ResourceTemplateGenerationAnnotationKey: "1",
+			},
+		},
+		Status: appsv1.ReplicaSetStatus{
+			Replicas:           3,
+			ReadyReplicas:      3,
+			AvailableReplicas:  3,
+			ObservedGeneration: 2,
+		},
+	}
+
+	tests := []struct {
+		name       string
+		replicaSet *appsv1.ReplicaSet
+		modifyFunc func(*unstructured.Unstructured)
+		want       *runtime.RawExtension
+		wantErr    bool
+	}{
+		{
+			name:       "replicaset with valid status and generation annotation",
+			replicaSet: validReplicaSet.DeepCopy(),
+			want: func() *runtime.RawExtension {
+				wantStatus := &WrappedReplicaSetStatus{
+					FederatedGeneration: FederatedGeneration{
+						Generation:                 2,
+						ResourceTemplateGeneration: 1,
+					},
+					ReplicaSetStatus: validReplicaSet.Status,
+				}
+				raw, _ := helper.BuildStatusRawExtension(wantStatus)
+				return raw
+			}(),
+			wantErr: false,
+		},
+		{
+			name:       "replicaset without status field",
+			replicaSet: validReplicaSet.DeepCopy(),
+			modifyFunc: func(u *unstructured.Unstructured) {
+				delete(u.Object, "status")
+			},
+			want:    nil,
+			wantErr: false,
+		},
+		{
+			name:       "replicaset with invalid generation annotation",
+			replicaSet: validReplicaSet.DeepCopy(),
+			modifyFunc: func(u *unstructured.Unstructured) {
+				annotations := u.GetAnnotations()
+				annotations[workv1alpha2.ResourceTemplateGenerationAnnotationKey] = "invalid"
+				u.SetAnnotations(annotations)
+			},
+			want:    nil,
+			wantErr: true,
+		},
+		{
+			name:       "replicaset without generation annotation",
+			replicaSet: validReplicaSet.DeepCopy(),
+			modifyFunc: func(u *unstructured.Unstructured) {
+				annotations := u.GetAnnotations()
+				delete(annotations, workv1alpha2.ResourceTemplateGenerationAnnotationKey)
+				u.SetAnnotations(annotations)
+			},
+			want:    nil,
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Convert replicaset to unstructured
+			unstrObj, err := helper.ToUnstructured(tt.replicaSet)
+			require.NoError(t, err, "Failed to convert replicaset to unstructured")
+
+			// Apply modifications if specified
+			if tt.modifyFunc != nil {
+				tt.modifyFunc(unstrObj)
+			}
+
+			got, err := reflectReplicaSetStatus(unstrObj)
+
+			if tt.wantErr {
+				assert.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+
+			if tt.want == nil {
+				assert.Nil(t, got)
+				return
+			}
+
+			assert.NotNil(t, got)
+			assert.JSONEq(t, string(tt.want.Raw), string(got.Raw))
+		})
+	}
+}
+
 func Test_reflectServiceStatus(t *testing.T) {
 	tests := []struct {
 		name    string
diff --git a/pkg/resourceinterpreter/default/native/replica_test.go b/pkg/resourceinterpreter/default/native/replica_test.go
index 8ea6849e6..a9e299bf9 100644
--- a/pkg/resourceinterpreter/default/native/replica_test.go
+++ b/pkg/resourceinterpreter/default/native/replica_test.go
@@ -34,6 +34,7 @@ import (
 func Test_getAllDefaultReplicaInterpreter(t *testing.T) {
 	expectedKinds := []schema.GroupVersionKind{
 		{Group: "apps", Version: "v1", Kind: "Deployment"},
+		{Group: "apps", Version: "v1", Kind: "ReplicaSet"},
 		{Group: "apps", Version: "v1", Kind: "StatefulSet"},
 		{Group: "batch", Version: "v1", Kind: "Job"},
 		{Group: "", Version: "v1", Kind: "Pod"},
@@ -152,6 +153,55 @@ func Test_statefulSetReplica(t *testing.T) {
 	assert.Equalf(t, wantRequirement, gotRequirement, "statefulSetReplica(%v)", unstructuredObject)
 }
 
+func Test_replicaSetReplica(t *testing.T) {
+	object := &appsv1.ReplicaSet{
+		Spec: appsv1.ReplicaSetSpec{
+			Replicas: ptr.To[int32](3),
+			Template: corev1.PodTemplateSpec{
+				Spec: corev1.PodSpec{
+					NodeSelector: map[string]string{"foo": "foo1"},
+					Tolerations:  []corev1.Toleration{{Key: "foo", Operator: corev1.TolerationOpExists, Effect: corev1.TaintEffectNoSchedule}},
+					Affinity: &corev1.Affinity{
+						NodeAffinity: &corev1.NodeAffinity{
+							RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{
+								NodeSelectorTerms: []corev1.NodeSelectorTerm{{
+									MatchFields: []corev1.NodeSelectorRequirement{{Key: "foo", Operator: corev1.NodeSelectorOpExists}},
+								}},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+	unstructuredObject, err := helper.ToUnstructured(object)
+	if err != nil {
+		klog.Errorf("Failed to transform object, error: %v", err)
+		return
+	}
+	gotReplica, gotRequirement, err := replicaSetReplica(unstructuredObject)
+
+	wantReplica := int32(3)
+	wantRequirement := &workv1alpha2.ReplicaRequirements{
+		NodeClaim: &workv1alpha2.NodeClaim{
+			NodeSelector: map[string]string{"foo": "foo1"},
+			Tolerations:  []corev1.Toleration{{Key: "foo", Operator: corev1.TolerationOpExists, Effect: corev1.TaintEffectNoSchedule}},
+			HardNodeAffinity: &corev1.NodeSelector{
+				NodeSelectorTerms: []corev1.NodeSelectorTerm{{
+					MatchFields: []corev1.NodeSelectorRequirement{{Key: "foo", Operator: corev1.NodeSelectorOpExists}},
+				}},
+			},
+		},
+	}
+
+	if err != nil {
+		t.Errorf("replicaSetReplica() error = %v, want nil", err)
+	}
+
+	assert.Equalf(t, wantReplica, gotReplica, "replicaSetReplica(%v)", unstructuredObject)
+	assert.Equalf(t, wantRequirement, gotRequirement, "replicaSetReplica(%v)", unstructuredObject)
+}
+
 func Test_jobReplica(t *testing.T) {
 	object := &batchv1.Job{
 		Spec: batchv1.JobSpec{
diff --git a/pkg/resourceinterpreter/default/native/revisereplica_test.go b/pkg/resourceinterpreter/default/native/revisereplica_test.go
index 39b80429a..6cf9a8309 100644
--- a/pkg/resourceinterpreter/default/native/revisereplica_test.go
+++ b/pkg/resourceinterpreter/default/native/revisereplica_test.go
@@ -100,6 +100,82 @@ func TestReviseDeploymentReplica(t *testing.T) {
 	}
 }
 
+func TestReviseReplicaSetReplica(t *testing.T) {
+	tests := []struct {
+		name        string
+		object      *unstructured.Unstructured
+		replica     int64
+		expected    *unstructured.Unstructured
+		expectError bool
+	}{
+		{
+			name: "ReplicaSet .spec.replicas accessor error, expected int64",
+			object: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "apps/v1",
+					"kind":       "ReplicaSet",
+					"metadata": map[string]interface{}{
+						"name": "fake-replicaset",
+					},
+					"spec": map[string]interface{}{
+						"replicas": 1,
+					},
+				},
+			},
+			replica:     3,
+			expectError: true,
+		},
+		{
+			name: "revise replicaset replica",
+			object: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "apps/v1",
+					"kind":       "ReplicaSet",
+					"metadata": map[string]interface{}{
+						"name": "fake-replicaset",
+					},
+					"spec": map[string]interface{}{
+						"replicas": int64(1),
+					},
+				},
+			},
+			replica: 3,
+			expected: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "apps/v1",
+					"kind":       "ReplicaSet",
+					"metadata": map[string]interface{}{
+						"name": "fake-replicaset",
+					},
+					"spec": map[string]interface{}{
+						"replicas": int64(3),
+					},
+				},
+			},
+			expectError: false,
+		},
+	}
+
+	for i := range tests {
+		tt := tests[i]
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			res, err := reviseReplicaSetReplica(tt.object, tt.replica)
+			if err == nil && tt.expectError == true {
+				t.Fatal("expect an error but got none")
+			}
+			if err != nil && tt.expectError != true {
+				t.Fatalf("expect no error but got: %v", err)
+			}
+			if err == nil && tt.expectError == false {
+				if !reflect.DeepEqual(res, tt.expected) {
+					t.Errorf("reviseReplicaSetReplica() = %v, want %v", res, tt.expected)
+				}
+			}
+		})
+	}
+}
+
 func TestReviseJobReplica(t *testing.T) {
 	tests := []struct {
 		name        string
@@ -253,6 +329,7 @@ func TestReviseStatefulSetReplica(t *testing.T) {
 func TestGetAllDefaultReviseReplicaInterpreter(t *testing.T) {
 	expectedKinds := []schema.GroupVersionKind{
 		{Group: "apps", Version: "v1", Kind: "Deployment"},
+		{Group: "apps", Version: "v1", Kind: "ReplicaSet"},
 		{Group: "apps", Version: "v1", Kind: "StatefulSet"},
 		{Group: "batch", Version: "v1", Kind: "Job"},
 	}
diff --git a/test/e2e/suites/base/failover_test.go b/test/e2e/suites/base/failover_test.go
index 201eb3c1d..17d6d6869 100644
--- a/test/e2e/suites/base/failover_test.go
+++ b/test/e2e/suites/base/failover_test.go
@@ -30,6 +30,7 @@ import (
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/rand"
 	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/klog/v2"
 	"k8s.io/utils/ptr"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
@@ -469,8 +470,8 @@ var _ = ginkgo.Describe("application failover testing", func() {
 						},
 					},
 				})
-				framework.CreateOverridePolicy(karmadaClient, overridePolicy)
 				beginTime = time.Now()
+				framework.CreateOverridePolicy(karmadaClient, overridePolicy)
 			})
 			defer framework.RemoveOverridePolicy(karmadaClient, policyNamespace, policyName)
 
@@ -488,8 +489,10 @@ var _ = ginkgo.Describe("application failover testing", func() {
 
 			ginkgo.By("check whether application failover with purgeMode gracefully when the GracePeriodSeconds is reach out", func() {
 				framework.WaitDeploymentDisappearOnClusters(disabledClusters, deploymentNamespace, deploymentName)
-				evictionTime := time.Now()
-				gomega.Expect(evictionTime.Sub(beginTime) > time.Duration(gracePeriodSeconds+tolerationSeconds)*time.Second).Should(gomega.BeTrue())
+				evictionTimeCost := time.Since(beginTime)
+				expectTimeCost := time.Second * time.Duration(gracePeriodSeconds+tolerationSeconds)
+				klog.Infof("application failover time cost: actual: %s, expect: %s", evictionTimeCost.String(), expectTimeCost.String())
+				gomega.Expect(evictionTimeCost >= expectTimeCost).Should(gomega.BeTrue())
 			})
 		})
 	})