diff --git a/README.md b/README.md
index a06746824..3cf0d81e7 100644
--- a/README.md
+++ b/README.md
@@ -116,7 +116,7 @@ You can find more details for cluster join process from this [design doc](https:
 1. Create a cluster set by `ManagedClusterSet` API
   ```
   cat << EOF | kubectl apply -f -
-  apiVersion: cluster.open-cluster-management.io/v1beta1
+  apiVersion: cluster.open-cluster-management.io/v1beta2
   kind: ManagedClusterSet
   metadata:
     name: clusterset1
diff --git a/pkg/hub/managedclusterset/controller.go b/pkg/hub/managedclusterset/controller.go
index 9c9c249eb..734180156 100644
--- a/pkg/hub/managedclusterset/controller.go
+++ b/pkg/hub/managedclusterset/controller.go
@@ -18,18 +18,18 @@ import (
 	"k8s.io/klog/v2"
 	clientset "open-cluster-management.io/api/client/cluster/clientset/versioned"
 	clusterinformerv1 "open-cluster-management.io/api/client/cluster/informers/externalversions/cluster/v1"
-	clusterinformerv1beta1 "open-cluster-management.io/api/client/cluster/informers/externalversions/cluster/v1beta1"
+	clusterinformerv1beta2 "open-cluster-management.io/api/client/cluster/informers/externalversions/cluster/v1beta2"
 	clusterlisterv1 "open-cluster-management.io/api/client/cluster/listers/cluster/v1"
-	clusterlisterv1beta1 "open-cluster-management.io/api/client/cluster/listers/cluster/v1beta1"
+	clusterlisterv1beta2 "open-cluster-management.io/api/client/cluster/listers/cluster/v1beta2"
 	v1 "open-cluster-management.io/api/cluster/v1"
-	clusterv1beta1 "open-cluster-management.io/api/cluster/v1beta1"
+	clusterv1beta2 "open-cluster-management.io/api/cluster/v1beta2"
 )
 
 // managedClusterSetController reconciles instances of ManagedClusterSet on the hub.
 type managedClusterSetController struct {
 	clusterClient    clientset.Interface
 	clusterLister    clusterlisterv1.ManagedClusterLister
-	clusterSetLister clusterlisterv1beta1.ManagedClusterSetLister
+	clusterSetLister clusterlisterv1beta2.ManagedClusterSetLister
 	eventRecorder    events.Recorder
 	queue            workqueue.RateLimitingInterface
 }
@@ -38,7 +38,7 @@ type managedClusterSetController struct {
 func NewManagedClusterSetController(
 	clusterClient clientset.Interface,
 	clusterInformer clusterinformerv1.ManagedClusterInformer,
-	clusterSetInformer clusterinformerv1beta1.ManagedClusterSetInformer,
+	clusterSetInformer clusterinformerv1beta2.ManagedClusterSetInformer,
 	recorder events.Recorder) factory.Controller {
 
 	controllerName := "managed-clusterset-controller"
@@ -136,16 +136,16 @@ func (c *managedClusterSetController) sync(ctx context.Context, syncCtx factory.
 }
 
 // syncClusterSet syncs a particular cluster set
-func (c *managedClusterSetController) syncClusterSet(ctx context.Context, originalClusterSet *clusterv1beta1.ManagedClusterSet) error {
+func (c *managedClusterSetController) syncClusterSet(ctx context.Context, originalClusterSet *clusterv1beta2.ManagedClusterSet) error {
 	clusterSet := originalClusterSet.DeepCopy()
-	clusters, err := clusterv1beta1.GetClustersFromClusterSet(clusterSet, c.clusterLister)
+	clusters, err := clusterv1beta2.GetClustersFromClusterSet(clusterSet, c.clusterLister)
 	if err != nil {
 		return err
 	}
 	count := len(clusters)
 	// update clusterset status
 	emptyCondition := metav1.Condition{
-		Type: clusterv1beta1.ManagedClusterSetConditionEmpty,
+		Type: clusterv1beta2.ManagedClusterSetConditionEmpty,
 	}
 	if count == 0 {
 		emptyCondition.Status = metav1.ConditionTrue
@@ -163,7 +163,7 @@ func (c *managedClusterSetController) syncClusterSet(ctx context.Context, origin
 		return nil
 	}
 
-	_, err = c.clusterClient.ClusterV1beta1().ManagedClusterSets().UpdateStatus(ctx, clusterSet, metav1.UpdateOptions{})
+	_, err = c.clusterClient.ClusterV1beta2().ManagedClusterSets().UpdateStatus(ctx, clusterSet, metav1.UpdateOptions{})
 	if err != nil {
 		return fmt.Errorf("failed to update status of ManagedClusterSet %q: %w", clusterSet.Name, err)
 	}
@@ -173,7 +173,7 @@ func (c *managedClusterSetController) syncClusterSet(ctx context.Context, origin
 
 // enqueueClusterClusterSet enqueue a cluster related clusterset
 func (c *managedClusterSetController) enqueueClusterClusterSet(cluster *v1.ManagedCluster) {
-	clusterSets, err := clusterv1beta1.GetClusterSetsOfCluster(cluster, c.clusterSetLister)
+	clusterSets, err := clusterv1beta2.GetClusterSetsOfCluster(cluster, c.clusterSetLister)
 	if err != nil {
 		utilruntime.HandleError(fmt.Errorf("error to get GetClusterSetsOfCluster. Error %v", err))
 		return
@@ -186,12 +186,12 @@ func (c *managedClusterSetController) enqueueClusterClusterSet(cluster *v1.Manag
 // enqueueUpdateClusterClusterSet get the oldCluster related clustersets and newCluster related clustersets,
 // then enqueue the diff clustersets(added clustersets and removed clustersets)
 func (c *managedClusterSetController) enqueueUpdateClusterClusterSet(oldCluster, newCluster *v1.ManagedCluster) {
-	oldClusterSets, err := clusterv1beta1.GetClusterSetsOfCluster(oldCluster, c.clusterSetLister)
+	oldClusterSets, err := clusterv1beta2.GetClusterSetsOfCluster(oldCluster, c.clusterSetLister)
 	if err != nil {
 		utilruntime.HandleError(fmt.Errorf("error to get GetClusterSetsOfCluster. Error %v", err))
 		return
 	}
-	newClusterSets, err := clusterv1beta1.GetClusterSetsOfCluster(newCluster, c.clusterSetLister)
+	newClusterSets, err := clusterv1beta2.GetClusterSetsOfCluster(newCluster, c.clusterSetLister)
 	if err != nil {
 		utilruntime.HandleError(fmt.Errorf("error to get GetClusterSetsOfCluster. Error %v", err))
 		return
@@ -204,7 +204,7 @@ func (c *managedClusterSetController) enqueueUpdateClusterClusterSet(oldCluster,
 }
 
 // getDiffClusterSetsNames return the diff clustersets names
-func getDiffClusterSetsNames(oldSets, newSets []*clusterv1beta1.ManagedClusterSet) sets.String {
+func getDiffClusterSetsNames(oldSets, newSets []*clusterv1beta2.ManagedClusterSet) sets.String {
 	oldSetsMap := sets.NewString()
 	newSetsMap := sets.NewString()
 
diff --git a/pkg/hub/managedclusterset/controller_test.go b/pkg/hub/managedclusterset/controller_test.go
index 61c1545dd..7eb849f98 100644
--- a/pkg/hub/managedclusterset/controller_test.go
+++ b/pkg/hub/managedclusterset/controller_test.go
@@ -13,32 +13,32 @@ import (
 	clusterfake "open-cluster-management.io/api/client/cluster/clientset/versioned/fake"
 	clusterinformers "open-cluster-management.io/api/client/cluster/informers/externalversions"
 	clusterv1 "open-cluster-management.io/api/cluster/v1"
-	clusterv1beta1 "open-cluster-management.io/api/cluster/v1beta1"
+	clusterv1beta2 "open-cluster-management.io/api/cluster/v1beta2"
 	testinghelpers "open-cluster-management.io/registration/pkg/helpers/testing"
 )
 
 func TestSyncClusterSet(t *testing.T) {
 	cases := []struct {
 		name               string
-		existingClusterSet *clusterv1beta1.ManagedClusterSet
+		existingClusterSet *clusterv1beta2.ManagedClusterSet
 		existingClusters   []*clusterv1.ManagedCluster
 		expectCondition    metav1.Condition
 		expectErr          bool
 	}{
 		{
 			name: "sync a empty cluster set",
-			existingClusterSet: &clusterv1beta1.ManagedClusterSet{
+			existingClusterSet: &clusterv1beta2.ManagedClusterSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name: "mcs1",
 				},
 			},
 			existingClusters: []*clusterv1.ManagedCluster{
 				newManagedCluster("cluster1", map[string]string{
-					clusterv1beta1.ClusterSetLabel: "mcs1",
+					clusterv1beta2.ClusterSetLabel: "mcs1",
 				}),
 			},
 			expectCondition: metav1.Condition{
-				Type:    clusterv1beta1.ManagedClusterSetConditionEmpty,
+				Type:    clusterv1beta2.ManagedClusterSetConditionEmpty,
 				Status:  metav1.ConditionFalse,
 				Reason:  "ClustersSelected",
 				Message: "1 ManagedClusters selected",
@@ -46,23 +46,23 @@ func TestSyncClusterSet(t *testing.T) {
 		},
 		{
 			name: "sync a legacy clusterset",
-			existingClusterSet: &clusterv1beta1.ManagedClusterSet{
+			existingClusterSet: &clusterv1beta2.ManagedClusterSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name: "mcs1",
 				},
-				Spec: clusterv1beta1.ManagedClusterSetSpec{
-					ClusterSelector: clusterv1beta1.ManagedClusterSelector{
-						SelectorType: clusterv1beta1.LegacyClusterSetLabel,
+				Spec: clusterv1beta2.ManagedClusterSetSpec{
+					ClusterSelector: clusterv1beta2.ManagedClusterSelector{
+						SelectorType: clusterv1beta2.ExclusiveClusterSetLabel,
 					},
 				},
 			},
 			existingClusters: []*clusterv1.ManagedCluster{
 				newManagedCluster("cluster1", map[string]string{
-					clusterv1beta1.ClusterSetLabel: "mcs1",
+					clusterv1beta2.ClusterSetLabel: "mcs1",
 				}),
 			},
 			expectCondition: metav1.Condition{
-				Type:    clusterv1beta1.ManagedClusterSetConditionEmpty,
+				Type:    clusterv1beta2.ManagedClusterSetConditionEmpty,
 				Status:  metav1.ConditionFalse,
 				Reason:  "ClustersSelected",
 				Message: "1 ManagedClusters selected",
@@ -70,13 +70,13 @@ func TestSyncClusterSet(t *testing.T) {
 		},
 		{
 			name: "sync a legacy clusterset, and no cluster matched",
-			existingClusterSet: &clusterv1beta1.ManagedClusterSet{
+			existingClusterSet: &clusterv1beta2.ManagedClusterSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name: "mcs1",
 				},
-				Spec: clusterv1beta1.ManagedClusterSetSpec{
-					ClusterSelector: clusterv1beta1.ManagedClusterSelector{
-						SelectorType: clusterv1beta1.LegacyClusterSetLabel,
+				Spec: clusterv1beta2.ManagedClusterSetSpec{
+					ClusterSelector: clusterv1beta2.ManagedClusterSelector{
+						SelectorType: clusterv1beta2.ExclusiveClusterSetLabel,
 					},
 				},
 			},
@@ -86,7 +86,7 @@ func TestSyncClusterSet(t *testing.T) {
 				}),
 			},
 			expectCondition: metav1.Condition{
-				Type:    clusterv1beta1.ManagedClusterSetConditionEmpty,
+				Type:    clusterv1beta2.ManagedClusterSetConditionEmpty,
 				Status:  metav1.ConditionTrue,
 				Reason:  "NoClusterMatched",
 				Message: "No ManagedCluster selected",
@@ -94,13 +94,13 @@ func TestSyncClusterSet(t *testing.T) {
 		},
 		{
 			name: "sync a labelselector clusterset",
-			existingClusterSet: &clusterv1beta1.ManagedClusterSet{
+			existingClusterSet: &clusterv1beta2.ManagedClusterSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name: "mcs1",
 				},
-				Spec: clusterv1beta1.ManagedClusterSetSpec{
-					ClusterSelector: clusterv1beta1.ManagedClusterSelector{
-						SelectorType: clusterv1beta1.LabelSelector,
+				Spec: clusterv1beta2.ManagedClusterSetSpec{
+					ClusterSelector: clusterv1beta2.ManagedClusterSelector{
+						SelectorType: clusterv1beta2.LabelSelector,
 						LabelSelector: &metav1.LabelSelector{
 							MatchLabels: map[string]string{
 								"vendor": "openShift",
@@ -111,16 +111,16 @@ func TestSyncClusterSet(t *testing.T) {
 			},
 			existingClusters: []*clusterv1.ManagedCluster{
 				newManagedCluster("cluster1", map[string]string{
-					clusterv1beta1.ClusterSetLabel: "mcs1",
+					clusterv1beta2.ClusterSetLabel: "mcs1",
 					"vendor":                       "openShift",
 				}),
 				newManagedCluster("cluster2", map[string]string{
-					clusterv1beta1.ClusterSetLabel: "mcs2",
+					clusterv1beta2.ClusterSetLabel: "mcs2",
 					"vendor":                       "openShift",
 				}),
 			},
 			expectCondition: metav1.Condition{
-				Type:    clusterv1beta1.ManagedClusterSetConditionEmpty,
+				Type:    clusterv1beta2.ManagedClusterSetConditionEmpty,
 				Status:  metav1.ConditionFalse,
 				Reason:  "ClustersSelected",
 				Message: "2 ManagedClusters selected",
@@ -128,29 +128,29 @@ func TestSyncClusterSet(t *testing.T) {
 		},
 		{
 			name: "sync a global clusterset",
-			existingClusterSet: &clusterv1beta1.ManagedClusterSet{
+			existingClusterSet: &clusterv1beta2.ManagedClusterSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name: "mcs1",
 				},
-				Spec: clusterv1beta1.ManagedClusterSetSpec{
-					ClusterSelector: clusterv1beta1.ManagedClusterSelector{
-						SelectorType:  clusterv1beta1.LabelSelector,
+				Spec: clusterv1beta2.ManagedClusterSetSpec{
+					ClusterSelector: clusterv1beta2.ManagedClusterSelector{
+						SelectorType:  clusterv1beta2.LabelSelector,
 						LabelSelector: &metav1.LabelSelector{},
 					},
 				},
 			},
 			existingClusters: []*clusterv1.ManagedCluster{
 				newManagedCluster("cluster1", map[string]string{
-					clusterv1beta1.ClusterSetLabel: "mcs1",
+					clusterv1beta2.ClusterSetLabel: "mcs1",
 					"vendor":                       "openShift",
 				}),
 				newManagedCluster("cluster2", map[string]string{
-					clusterv1beta1.ClusterSetLabel: "mcs2",
+					clusterv1beta2.ClusterSetLabel: "mcs2",
 					"vendor":                       "openShift",
 				}),
 			},
 			expectCondition: metav1.Condition{
-				Type:    clusterv1beta1.ManagedClusterSetConditionEmpty,
+				Type:    clusterv1beta2.ManagedClusterSetConditionEmpty,
 				Status:  metav1.ConditionFalse,
 				Reason:  "ClustersSelected",
 				Message: "2 ManagedClusters selected",
@@ -158,28 +158,28 @@ func TestSyncClusterSet(t *testing.T) {
 		},
 		{
 			name: "sync a label clusterset with no labelselector specified(no cluster matched)",
-			existingClusterSet: &clusterv1beta1.ManagedClusterSet{
+			existingClusterSet: &clusterv1beta2.ManagedClusterSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name: "mcs1",
 				},
-				Spec: clusterv1beta1.ManagedClusterSetSpec{
-					ClusterSelector: clusterv1beta1.ManagedClusterSelector{
-						SelectorType: clusterv1beta1.LabelSelector,
+				Spec: clusterv1beta2.ManagedClusterSetSpec{
+					ClusterSelector: clusterv1beta2.ManagedClusterSelector{
+						SelectorType: clusterv1beta2.LabelSelector,
 					},
 				},
 			},
 			existingClusters: []*clusterv1.ManagedCluster{
 				newManagedCluster("cluster1", map[string]string{
-					clusterv1beta1.ClusterSetLabel: "mcs1",
+					clusterv1beta2.ClusterSetLabel: "mcs1",
 					"vendor":                       "openShift",
 				}),
 				newManagedCluster("cluster2", map[string]string{
-					clusterv1beta1.ClusterSetLabel: "mcs2",
+					clusterv1beta2.ClusterSetLabel: "mcs2",
 					"vendor":                       "openShift",
 				}),
 			},
 			expectCondition: metav1.Condition{
-				Type:    clusterv1beta1.ManagedClusterSetConditionEmpty,
+				Type:    clusterv1beta2.ManagedClusterSetConditionEmpty,
 				Status:  metav1.ConditionTrue,
 				Reason:  "NoClusterMatched",
 				Message: "No ManagedCluster selected",
@@ -187,12 +187,12 @@ func TestSyncClusterSet(t *testing.T) {
 		},
 		{
 			name: "ignore any other clusterset",
-			existingClusterSet: &clusterv1beta1.ManagedClusterSet{
+			existingClusterSet: &clusterv1beta2.ManagedClusterSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name: "mcs1",
 				},
-				Spec: clusterv1beta1.ManagedClusterSetSpec{
-					ClusterSelector: clusterv1beta1.ManagedClusterSelector{
+				Spec: clusterv1beta2.ManagedClusterSetSpec{
+					ClusterSelector: clusterv1beta2.ManagedClusterSelector{
 						SelectorType: "SingleClusterLabel",
 					},
 				},
@@ -221,7 +221,7 @@ func TestSyncClusterSet(t *testing.T) {
 				}
 			}
 			if c.existingClusterSet != nil {
-				err := informerFactory.Cluster().V1beta1().ManagedClusterSets().Informer().GetStore().Add(c.existingClusterSet)
+				err := informerFactory.Cluster().V1beta2().ManagedClusterSets().Informer().GetStore().Add(c.existingClusterSet)
 				if err != nil {
 					t.Errorf("Failed to add clusterset: %v, error: %v", c.existingClusterSet.Name, err)
 				}
@@ -230,7 +230,7 @@ func TestSyncClusterSet(t *testing.T) {
 			ctrl := managedClusterSetController{
 				clusterClient:    clusterClient,
 				clusterLister:    informerFactory.Cluster().V1().ManagedClusters().Lister(),
-				clusterSetLister: informerFactory.Cluster().V1beta1().ManagedClusterSets().Lister(),
+				clusterSetLister: informerFactory.Cluster().V1beta2().ManagedClusterSets().Lister(),
 				eventRecorder:    eventstesting.NewTestingEventRecorder(t),
 			}
 
@@ -245,7 +245,7 @@ func TestSyncClusterSet(t *testing.T) {
 			if syncErr != nil {
 				t.Errorf("unexpected err: %v", syncErr)
 			}
-			updatedSet, err := clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.Background(), c.existingClusterSet.Name, metav1.GetOptions{})
+			updatedSet, err := clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.Background(), c.existingClusterSet.Name, metav1.GetOptions{})
 			if err != nil {
 				t.Errorf("Failed to get clusterset: %v, error: %v", c.existingClusterSet.Name, err)
 			}
@@ -259,54 +259,54 @@ func TestSyncClusterSet(t *testing.T) {
 func TestGetDiffClustersets(t *testing.T) {
 	cases := []struct {
 		name          string
-		oldSets       []*clusterv1beta1.ManagedClusterSet
-		newSets       []*clusterv1beta1.ManagedClusterSet
+		oldSets       []*clusterv1beta2.ManagedClusterSet
+		newSets       []*clusterv1beta2.ManagedClusterSet
 		expectDiffSet sets.String
 	}{
 		{
 			name: "update a set",
-			oldSets: []*clusterv1beta1.ManagedClusterSet{
+			oldSets: []*clusterv1beta2.ManagedClusterSet{
 				newManagedClusterSet("s1"), newManagedClusterSet("s2"),
 			},
-			newSets: []*clusterv1beta1.ManagedClusterSet{
+			newSets: []*clusterv1beta2.ManagedClusterSet{
 				newManagedClusterSet("s1"), newManagedClusterSet("s3"),
 			},
 			expectDiffSet: sets.NewString("s2", "s3"),
 		},
 		{
 			name: "add a set",
-			oldSets: []*clusterv1beta1.ManagedClusterSet{
+			oldSets: []*clusterv1beta2.ManagedClusterSet{
 				newManagedClusterSet("s1"),
 			},
-			newSets: []*clusterv1beta1.ManagedClusterSet{
+			newSets: []*clusterv1beta2.ManagedClusterSet{
 				newManagedClusterSet("s1"), newManagedClusterSet("s2"),
 			},
 			expectDiffSet: sets.NewString("s2"),
 		},
 		{
 			name: "delete a set",
-			oldSets: []*clusterv1beta1.ManagedClusterSet{
+			oldSets: []*clusterv1beta2.ManagedClusterSet{
 				newManagedClusterSet("s1"), newManagedClusterSet("s2"),
 			},
-			newSets: []*clusterv1beta1.ManagedClusterSet{
+			newSets: []*clusterv1beta2.ManagedClusterSet{
 				newManagedClusterSet("s1"),
 			},
 			expectDiffSet: sets.NewString("s2"),
 		},
 		{
 			name:    "old set is nil",
-			oldSets: []*clusterv1beta1.ManagedClusterSet{},
-			newSets: []*clusterv1beta1.ManagedClusterSet{
+			oldSets: []*clusterv1beta2.ManagedClusterSet{},
+			newSets: []*clusterv1beta2.ManagedClusterSet{
 				newManagedClusterSet("s1"),
 			},
 			expectDiffSet: sets.NewString("s1"),
 		},
 		{
 			name: "new set is nil",
-			oldSets: []*clusterv1beta1.ManagedClusterSet{
+			oldSets: []*clusterv1beta2.ManagedClusterSet{
 				newManagedClusterSet("s1"),
 			},
-			newSets:       []*clusterv1beta1.ManagedClusterSet{},
+			newSets:       []*clusterv1beta2.ManagedClusterSet{},
 			expectDiffSet: sets.NewString("s1"),
 		},
 	}
@@ -324,39 +324,39 @@ func TestGetDiffClustersets(t *testing.T) {
 func TestEnqueueUpdateClusterClusterSet(t *testing.T) {
 	cases := []struct {
 		name                string
-		existingClusterSets []*clusterv1beta1.ManagedClusterSet
+		existingClusterSets []*clusterv1beta2.ManagedClusterSet
 		oldCluster          *clusterv1.ManagedCluster
 		newCluster          *clusterv1.ManagedCluster
 		expectQueueLen      int
 	}{
 		{
 			name: "update a cluster's clusterset",
-			existingClusterSets: []*clusterv1beta1.ManagedClusterSet{
+			existingClusterSets: []*clusterv1beta2.ManagedClusterSet{
 				newManagedClusterSet("mcs1"),
 				newManagedClusterSet("mcs2"),
 			},
-			oldCluster:     newClusterWithLabel("c1", map[string]string{clusterv1beta1.ClusterSetLabel: "mcs1"}),
-			newCluster:     newClusterWithLabel("c1", map[string]string{clusterv1beta1.ClusterSetLabel: "mcs2"}),
+			oldCluster:     newClusterWithLabel("c1", map[string]string{clusterv1beta2.ClusterSetLabel: "mcs1"}),
+			newCluster:     newClusterWithLabel("c1", map[string]string{clusterv1beta2.ClusterSetLabel: "mcs2"}),
 			expectQueueLen: 2,
 		},
 		{
 			name: "add a cluster's clusterset",
-			existingClusterSets: []*clusterv1beta1.ManagedClusterSet{
+			existingClusterSets: []*clusterv1beta2.ManagedClusterSet{
 				newManagedClusterSet("mcs1"),
 				newManagedClusterSet("mcs2"),
 			},
 			oldCluster:     newClusterWithLabel("c1", nil),
-			newCluster:     newClusterWithLabel("c1", map[string]string{clusterv1beta1.ClusterSetLabel: "mcs2"}),
+			newCluster:     newClusterWithLabel("c1", map[string]string{clusterv1beta2.ClusterSetLabel: "mcs2"}),
 			expectQueueLen: 1,
 		},
 		{
 			name: "remove a cluster's clusterset",
-			existingClusterSets: []*clusterv1beta1.ManagedClusterSet{
+			existingClusterSets: []*clusterv1beta2.ManagedClusterSet{
 				newManagedClusterSet("mcs1"),
 				newManagedClusterSet("mcs2"),
 			},
 			newCluster:     newClusterWithLabel("c1", nil),
-			oldCluster:     newClusterWithLabel("c1", map[string]string{clusterv1beta1.ClusterSetLabel: "mcs2"}),
+			oldCluster:     newClusterWithLabel("c1", map[string]string{clusterv1beta2.ClusterSetLabel: "mcs2"}),
 			expectQueueLen: 1,
 		},
 	}
@@ -372,7 +372,7 @@ func TestEnqueueUpdateClusterClusterSet(t *testing.T) {
 
 			informerFactory := clusterinformers.NewSharedInformerFactory(clusterClient, 5*time.Minute)
 			for _, clusterset := range c.existingClusterSets {
-				err := informerFactory.Cluster().V1beta1().ManagedClusterSets().Informer().GetStore().Add(clusterset)
+				err := informerFactory.Cluster().V1beta2().ManagedClusterSets().Informer().GetStore().Add(clusterset)
 				if err != nil {
 					t.Errorf("Failed to add clusterset: %v, error: %v", clusterset, err)
 				}
@@ -381,7 +381,7 @@ func TestEnqueueUpdateClusterClusterSet(t *testing.T) {
 
 			ctrl := managedClusterSetController{
 				clusterClient:    clusterClient,
-				clusterSetLister: informerFactory.Cluster().V1beta1().ManagedClusterSets().Lister(),
+				clusterSetLister: informerFactory.Cluster().V1beta2().ManagedClusterSets().Lister(),
 				eventRecorder:    eventstesting.NewTestingEventRecorder(t),
 				queue:            syncCtx.Queue(),
 			}
@@ -404,8 +404,8 @@ func newManagedCluster(name string, labels map[string]string) *clusterv1.Managed
 	return cluster
 }
 
-func newManagedClusterSet(name string) *clusterv1beta1.ManagedClusterSet {
-	clusterSet := &clusterv1beta1.ManagedClusterSet{
+func newManagedClusterSet(name string) *clusterv1beta2.ManagedClusterSet {
+	clusterSet := &clusterv1beta2.ManagedClusterSet{
 		ObjectMeta: metav1.ObjectMeta{
 			Name: name,
 		},
diff --git a/pkg/hub/managedclusterset/default_managedclusterset_controller.go b/pkg/hub/managedclusterset/default_managedclusterset_controller.go
index 63bf5b04f..6ff7cf93b 100644
--- a/pkg/hub/managedclusterset/default_managedclusterset_controller.go
+++ b/pkg/hub/managedclusterset/default_managedclusterset_controller.go
@@ -13,10 +13,10 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/klog/v2"
-	clustersetv1beta1 "open-cluster-management.io/api/client/cluster/clientset/versioned/typed/cluster/v1beta1"
-	clusterinformerv1beta1 "open-cluster-management.io/api/client/cluster/informers/externalversions/cluster/v1beta1"
-	clusterlisterv1beta1 "open-cluster-management.io/api/client/cluster/listers/cluster/v1beta1"
-	clusterv1beta1 "open-cluster-management.io/api/cluster/v1beta1"
+	clustersetv1beta2 "open-cluster-management.io/api/client/cluster/clientset/versioned/typed/cluster/v1beta2"
+	clusterinformerv1beta2 "open-cluster-management.io/api/client/cluster/informers/externalversions/cluster/v1beta2"
+	clusterlisterv1beta2 "open-cluster-management.io/api/client/cluster/listers/cluster/v1beta2"
+	clusterv1beta2 "open-cluster-management.io/api/cluster/v1beta2"
 )
 
 const (
@@ -24,26 +24,26 @@ const (
 	DefaultManagedClusterSetName = "default"
 )
 
-var DefaultManagedClusterSet = &clusterv1beta1.ManagedClusterSet{
+var DefaultManagedClusterSet = &clusterv1beta2.ManagedClusterSet{
 	ObjectMeta: metav1.ObjectMeta{
 		Name: DefaultManagedClusterSetName,
 	},
-	Spec: clusterv1beta1.ManagedClusterSetSpec{
-		ClusterSelector: clusterv1beta1.ManagedClusterSelector{
-			SelectorType: clusterv1beta1.LegacyClusterSetLabel,
+	Spec: clusterv1beta2.ManagedClusterSetSpec{
+		ClusterSelector: clusterv1beta2.ManagedClusterSelector{
+			SelectorType: clusterv1beta2.ExclusiveClusterSetLabel,
 		},
 	},
 }
 
 type defaultManagedClusterSetController struct {
-	clusterSetClient clustersetv1beta1.ClusterV1beta1Interface
-	clusterSetLister clusterlisterv1beta1.ManagedClusterSetLister
+	clusterSetClient clustersetv1beta2.ClusterV1beta2Interface
+	clusterSetLister clusterlisterv1beta2.ManagedClusterSetLister
 	eventRecorder    events.Recorder
 }
 
 func NewDefaultManagedClusterSetController(
-	clusterSetClient clustersetv1beta1.ClusterV1beta1Interface,
-	clusterSetInformer clusterinformerv1beta1.ManagedClusterSetInformer,
+	clusterSetClient clustersetv1beta2.ClusterV1beta2Interface,
+	clusterSetInformer clusterinformerv1beta2.ManagedClusterSetInformer,
 	recorder events.Recorder) factory.Controller {
 
 	c := &defaultManagedClusterSetController{
@@ -100,7 +100,7 @@ func (c *defaultManagedClusterSetController) sync(ctx context.Context, syncCtx f
 }
 
 // syncDefaultClusterSet syncs default cluster set.
-func (c *defaultManagedClusterSetController) syncDefaultClusterSet(ctx context.Context, originalDefaultClusterSet *clusterv1beta1.ManagedClusterSet) error {
+func (c *defaultManagedClusterSetController) syncDefaultClusterSet(ctx context.Context, originalDefaultClusterSet *clusterv1beta2.ManagedClusterSet) error {
 	defaultClusterSet := originalDefaultClusterSet.DeepCopy()
 
 	// if the annotation has set to disable, default clusterset controller will not work.
@@ -124,7 +124,7 @@ func (c *defaultManagedClusterSetController) syncDefaultClusterSet(ctx context.C
 	return nil
 }
 
-func hasAnnotation(set *clusterv1beta1.ManagedClusterSet, key, value string) bool {
+func hasAnnotation(set *clusterv1beta2.ManagedClusterSet, key, value string) bool {
 	if set.Annotations == nil {
 		return false
 	}
diff --git a/pkg/hub/managedclusterset/default_managedclusterset_controller_test.go b/pkg/hub/managedclusterset/default_managedclusterset_controller_test.go
index 4d4a6f9d2..3939b3eff 100644
--- a/pkg/hub/managedclusterset/default_managedclusterset_controller_test.go
+++ b/pkg/hub/managedclusterset/default_managedclusterset_controller_test.go
@@ -12,21 +12,21 @@ import (
 	clienttesting "k8s.io/client-go/testing"
 	clusterfake "open-cluster-management.io/api/client/cluster/clientset/versioned/fake"
 	clusterinformers "open-cluster-management.io/api/client/cluster/informers/externalversions"
-	clusterv1beta1 "open-cluster-management.io/api/cluster/v1beta1"
+	clusterv1beta2 "open-cluster-management.io/api/cluster/v1beta2"
 	testinghelpers "open-cluster-management.io/registration/pkg/helpers/testing"
 )
 
 func TestSyncDefaultClusterSet(t *testing.T) {
 
-	var editedDefaultManagedClusterSetSpec = clusterv1beta1.ManagedClusterSetSpec{
-		ClusterSelector: clusterv1beta1.ManagedClusterSelector{
+	var editedDefaultManagedClusterSetSpec = clusterv1beta2.ManagedClusterSetSpec{
+		ClusterSelector: clusterv1beta2.ManagedClusterSelector{
 			SelectorType: "non-LegacyClusterSetLabel",
 		},
 	}
 
 	cases := []struct {
 		name               string
-		existingClusterSet *clusterv1beta1.ManagedClusterSet
+		existingClusterSet *clusterv1beta2.ManagedClusterSet
 		validateActions    func(t *testing.T, actions []clienttesting.Action)
 	}{
 		{
@@ -42,7 +42,7 @@ func TestSyncDefaultClusterSet(t *testing.T) {
 			validateActions: func(t *testing.T, actions []clienttesting.Action) {
 
 				testinghelpers.AssertActions(t, actions, "update")
-				clusterset := actions[0].(clienttesting.UpdateAction).GetObject().(*clusterv1beta1.ManagedClusterSet)
+				clusterset := actions[0].(clienttesting.UpdateAction).GetObject().(*clusterv1beta2.ManagedClusterSet)
 				// if spec not rollbacked, error
 				if !equality.Semantic.DeepEqual(clusterset.Spec, DefaultManagedClusterSet.Spec) {
 					t.Errorf("Failed to rollback default managed cluster set spec after it is edited")
@@ -61,7 +61,7 @@ func TestSyncDefaultClusterSet(t *testing.T) {
 			// default cluster set should be created if it is deleted.
 			validateActions: func(t *testing.T, actions []clienttesting.Action) {
 				testinghelpers.AssertActions(t, actions, "create")
-				clusterset := actions[0].(clienttesting.CreateAction).GetObject().(*clusterv1beta1.ManagedClusterSet)
+				clusterset := actions[0].(clienttesting.CreateAction).GetObject().(*clusterv1beta2.ManagedClusterSet)
 				if clusterset.ObjectMeta.Name != DefaultManagedClusterSetName {
 					t.Errorf("Failed to create default managed cluster set")
 				}
@@ -88,14 +88,14 @@ func TestSyncDefaultClusterSet(t *testing.T) {
 			informerFactory := clusterinformers.NewSharedInformerFactory(clusterSetClient, 5*time.Minute)
 
 			if c.existingClusterSet != nil {
-				if err := informerFactory.Cluster().V1beta1().ManagedClusterSets().Informer().GetStore().Add(c.existingClusterSet); err != nil {
+				if err := informerFactory.Cluster().V1beta2().ManagedClusterSets().Informer().GetStore().Add(c.existingClusterSet); err != nil {
 					t.Fatal(err)
 				}
 			}
 
 			ctrl := defaultManagedClusterSetController{
-				clusterSetClient: clusterSetClient.ClusterV1beta1(),
-				clusterSetLister: informerFactory.Cluster().V1beta1().ManagedClusterSets().Lister(),
+				clusterSetClient: clusterSetClient.ClusterV1beta2(),
+				clusterSetLister: informerFactory.Cluster().V1beta2().ManagedClusterSets().Lister(),
 				eventRecorder:    eventstesting.NewTestingEventRecorder(t),
 			}
 
@@ -110,8 +110,8 @@ func TestSyncDefaultClusterSet(t *testing.T) {
 	}
 }
 
-func newDefaultManagedClusterSet(name string, spec clusterv1beta1.ManagedClusterSetSpec, terminating bool) *clusterv1beta1.ManagedClusterSet {
-	clusterSet := &clusterv1beta1.ManagedClusterSet{
+func newDefaultManagedClusterSet(name string, spec clusterv1beta2.ManagedClusterSetSpec, terminating bool) *clusterv1beta2.ManagedClusterSet {
+	clusterSet := &clusterv1beta2.ManagedClusterSet{
 		ObjectMeta: metav1.ObjectMeta{
 			Name: name,
 		},
@@ -125,8 +125,8 @@ func newDefaultManagedClusterSet(name string, spec clusterv1beta1.ManagedCluster
 	return clusterSet
 }
 
-func newDefaultManagedClusterSetWithAnnotation(name string, k, v string, spec clusterv1beta1.ManagedClusterSetSpec, terminating bool) *clusterv1beta1.ManagedClusterSet {
-	clusterSet := &clusterv1beta1.ManagedClusterSet{
+func newDefaultManagedClusterSetWithAnnotation(name string, k, v string, spec clusterv1beta2.ManagedClusterSetSpec, terminating bool) *clusterv1beta2.ManagedClusterSet {
+	clusterSet := &clusterv1beta2.ManagedClusterSet{
 		ObjectMeta: metav1.ObjectMeta{
 			Name: name,
 			Annotations: map[string]string{
diff --git a/pkg/hub/managedclusterset/global_managedclusterset_controller.go b/pkg/hub/managedclusterset/global_managedclusterset_controller.go
index 496d9e400..f7b57c538 100644
--- a/pkg/hub/managedclusterset/global_managedclusterset_controller.go
+++ b/pkg/hub/managedclusterset/global_managedclusterset_controller.go
@@ -13,37 +13,37 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/klog/v2"
-	clustersetv1beta1 "open-cluster-management.io/api/client/cluster/clientset/versioned/typed/cluster/v1beta1"
-	clusterinformerv1beta1 "open-cluster-management.io/api/client/cluster/informers/externalversions/cluster/v1beta1"
-	clusterlisterv1beta1 "open-cluster-management.io/api/client/cluster/listers/cluster/v1beta1"
-	clusterv1beta1 "open-cluster-management.io/api/cluster/v1beta1"
+	clustersetv1beta2 "open-cluster-management.io/api/client/cluster/clientset/versioned/typed/cluster/v1beta2"
+	clusterinformerv1beta2 "open-cluster-management.io/api/client/cluster/informers/externalversions/cluster/v1beta2"
+	clusterlisterv1beta2 "open-cluster-management.io/api/client/cluster/listers/cluster/v1beta2"
+	clusterv1beta2 "open-cluster-management.io/api/cluster/v1beta2"
 )
 
 const (
 	GlobalManagedClusterSetName = "global"
 )
 
-var GlobalManagedClusterSet = &clusterv1beta1.ManagedClusterSet{
+var GlobalManagedClusterSet = &clusterv1beta2.ManagedClusterSet{
 	ObjectMeta: metav1.ObjectMeta{
 		Name: GlobalManagedClusterSetName,
 	},
-	Spec: clusterv1beta1.ManagedClusterSetSpec{
-		ClusterSelector: clusterv1beta1.ManagedClusterSelector{
-			SelectorType:  clusterv1beta1.LabelSelector,
+	Spec: clusterv1beta2.ManagedClusterSetSpec{
+		ClusterSelector: clusterv1beta2.ManagedClusterSelector{
+			SelectorType:  clusterv1beta2.LabelSelector,
 			LabelSelector: &metav1.LabelSelector{},
 		},
 	},
 }
 
 type globalManagedClusterSetController struct {
-	clusterSetClient clustersetv1beta1.ClusterV1beta1Interface
-	clusterSetLister clusterlisterv1beta1.ManagedClusterSetLister
+	clusterSetClient clustersetv1beta2.ClusterV1beta2Interface
+	clusterSetLister clusterlisterv1beta2.ManagedClusterSetLister
 	eventRecorder    events.Recorder
 }
 
 func NewGlobalManagedClusterSetController(
-	clusterSetClient clustersetv1beta1.ClusterV1beta1Interface,
-	clusterSetInformer clusterinformerv1beta1.ManagedClusterSetInformer,
+	clusterSetClient clustersetv1beta2.ClusterV1beta2Interface,
+	clusterSetInformer clusterinformerv1beta2.ManagedClusterSetInformer,
 	recorder events.Recorder) factory.Controller {
 
 	c := &globalManagedClusterSetController{
@@ -99,7 +99,7 @@ func (c *globalManagedClusterSetController) sync(ctx context.Context, syncCtx fa
 }
 
 // applyGlobalClusterSet syncs global cluster set.
-func (c *globalManagedClusterSetController) applyGlobalClusterSet(ctx context.Context, originalGlobalClusterSet *clusterv1beta1.ManagedClusterSet) error {
+func (c *globalManagedClusterSetController) applyGlobalClusterSet(ctx context.Context, originalGlobalClusterSet *clusterv1beta2.ManagedClusterSet) error {
 	globalClusterSet := originalGlobalClusterSet.DeepCopy()
 
 	// if the annotation has set to disable, global clusterset controller will not work.
diff --git a/pkg/hub/managedclusterset/global_managedclusterset_controller_test.go b/pkg/hub/managedclusterset/global_managedclusterset_controller_test.go
index e5dfb4a08..f1cbd9d44 100644
--- a/pkg/hub/managedclusterset/global_managedclusterset_controller_test.go
+++ b/pkg/hub/managedclusterset/global_managedclusterset_controller_test.go
@@ -12,21 +12,21 @@ import (
 	clienttesting "k8s.io/client-go/testing"
 	clusterfake "open-cluster-management.io/api/client/cluster/clientset/versioned/fake"
 	clusterinformers "open-cluster-management.io/api/client/cluster/informers/externalversions"
-	clusterv1beta1 "open-cluster-management.io/api/cluster/v1beta1"
+	clusterv1beta2 "open-cluster-management.io/api/cluster/v1beta2"
 	testinghelpers "open-cluster-management.io/registration/pkg/helpers/testing"
 )
 
 func TestSyncGlobalClusterSet(t *testing.T) {
 
-	var editedGlobalManagedClusterSetSpec = clusterv1beta1.ManagedClusterSetSpec{
-		ClusterSelector: clusterv1beta1.ManagedClusterSelector{
+	var editedGlobalManagedClusterSetSpec = clusterv1beta2.ManagedClusterSetSpec{
+		ClusterSelector: clusterv1beta2.ManagedClusterSelector{
 			SelectorType: "non-LegacyClusterSetLabel",
 		},
 	}
 
 	cases := []struct {
 		name               string
-		existingClusterSet *clusterv1beta1.ManagedClusterSet
+		existingClusterSet *clusterv1beta2.ManagedClusterSet
 		validateActions    func(t *testing.T, actions []clienttesting.Action)
 	}{
 		{
@@ -42,7 +42,7 @@ func TestSyncGlobalClusterSet(t *testing.T) {
 			validateActions: func(t *testing.T, actions []clienttesting.Action) {
 
 				testinghelpers.AssertActions(t, actions, "update")
-				clusterset := actions[0].(clienttesting.UpdateAction).GetObject().(*clusterv1beta1.ManagedClusterSet)
+				clusterset := actions[0].(clienttesting.UpdateAction).GetObject().(*clusterv1beta2.ManagedClusterSet)
 				// if spec not rollbacked, error
 				if !equality.Semantic.DeepEqual(clusterset.Spec, GlobalManagedClusterSet.Spec) {
 					t.Errorf("Failed to rollback global managed cluster set spec after it is edited")
@@ -54,7 +54,7 @@ func TestSyncGlobalClusterSet(t *testing.T) {
 			// global cluster set should be created if it is deleted.
 			validateActions: func(t *testing.T, actions []clienttesting.Action) {
 				testinghelpers.AssertActions(t, actions, "create")
-				clusterset := actions[0].(clienttesting.CreateAction).GetObject().(*clusterv1beta1.ManagedClusterSet)
+				clusterset := actions[0].(clienttesting.CreateAction).GetObject().(*clusterv1beta2.ManagedClusterSet)
 				if clusterset.ObjectMeta.Name != GlobalManagedClusterSetName {
 					t.Errorf("Failed to create global managed cluster set")
 				}
@@ -81,14 +81,14 @@ func TestSyncGlobalClusterSet(t *testing.T) {
 			informerFactory := clusterinformers.NewSharedInformerFactory(clusterSetClient, 5*time.Minute)
 
 			if c.existingClusterSet != nil {
-				if err := informerFactory.Cluster().V1beta1().ManagedClusterSets().Informer().GetStore().Add(c.existingClusterSet); err != nil {
+				if err := informerFactory.Cluster().V1beta2().ManagedClusterSets().Informer().GetStore().Add(c.existingClusterSet); err != nil {
 					t.Fatal(err)
 				}
 			}
 
 			ctrl := globalManagedClusterSetController{
-				clusterSetClient: clusterSetClient.ClusterV1beta1(),
-				clusterSetLister: informerFactory.Cluster().V1beta1().ManagedClusterSets().Lister(),
+				clusterSetClient: clusterSetClient.ClusterV1beta2(),
+				clusterSetLister: informerFactory.Cluster().V1beta2().ManagedClusterSets().Lister(),
 				eventRecorder:    eventstesting.NewTestingEventRecorder(t),
 			}
 
@@ -102,8 +102,8 @@ func TestSyncGlobalClusterSet(t *testing.T) {
 	}
 }
 
-func newGlobalManagedClusterSet(name string, spec clusterv1beta1.ManagedClusterSetSpec, terminating bool) *clusterv1beta1.ManagedClusterSet {
-	clusterSet := &clusterv1beta1.ManagedClusterSet{
+func newGlobalManagedClusterSet(name string, spec clusterv1beta2.ManagedClusterSetSpec, terminating bool) *clusterv1beta2.ManagedClusterSet {
+	clusterSet := &clusterv1beta2.ManagedClusterSet{
 		ObjectMeta: metav1.ObjectMeta{
 			Name: name,
 		},
@@ -117,8 +117,8 @@ func newGlobalManagedClusterSet(name string, spec clusterv1beta1.ManagedClusterS
 	return clusterSet
 }
 
-func newGlobalManagedClusterSetWithAnnotation(name string, k, v string, spec clusterv1beta1.ManagedClusterSetSpec, terminating bool) *clusterv1beta1.ManagedClusterSet {
-	clusterSet := &clusterv1beta1.ManagedClusterSet{
+func newGlobalManagedClusterSetWithAnnotation(name string, k, v string, spec clusterv1beta2.ManagedClusterSetSpec, terminating bool) *clusterv1beta2.ManagedClusterSet {
+	clusterSet := &clusterv1beta2.ManagedClusterSet{
 		ObjectMeta: metav1.ObjectMeta{
 			Name: name,
 			Annotations: map[string]string{
diff --git a/pkg/hub/managedclustersetbinding/controller.go b/pkg/hub/managedclustersetbinding/controller.go
index aeb72d1d9..e0a46924d 100644
--- a/pkg/hub/managedclustersetbinding/controller.go
+++ b/pkg/hub/managedclustersetbinding/controller.go
@@ -19,9 +19,9 @@ import (
 	"k8s.io/client-go/util/workqueue"
 	"k8s.io/klog/v2"
 	clientset "open-cluster-management.io/api/client/cluster/clientset/versioned"
-	clusterinformerv1beta1 "open-cluster-management.io/api/client/cluster/informers/externalversions/cluster/v1beta1"
-	clusterlisterv1beta1 "open-cluster-management.io/api/client/cluster/listers/cluster/v1beta1"
-	clusterv1beta1 "open-cluster-management.io/api/cluster/v1beta1"
+	clusterinformerv1beta2 "open-cluster-management.io/api/client/cluster/informers/externalversions/cluster/v1beta2"
+	clusterlisterv1beta2 "open-cluster-management.io/api/client/cluster/listers/cluster/v1beta2"
+	clusterv1beta2 "open-cluster-management.io/api/cluster/v1beta2"
 )
 
 const (
@@ -31,8 +31,8 @@ const (
 // managedClusterSetController reconciles instances of ManagedClusterSet on the hub.
 type managedClusterSetBindingController struct {
 	clusterClient             clientset.Interface
-	clusterSetBindingLister   clusterlisterv1beta1.ManagedClusterSetBindingLister
-	clusterSetLister          clusterlisterv1beta1.ManagedClusterSetLister
+	clusterSetBindingLister   clusterlisterv1beta2.ManagedClusterSetBindingLister
+	clusterSetLister          clusterlisterv1beta2.ManagedClusterSetLister
 	clusterSetBindingIndexers cache.Indexer
 	queue                     workqueue.RateLimitingInterface
 	eventRecorder             events.Recorder
@@ -40,8 +40,8 @@ type managedClusterSetBindingController struct {
 
 func NewManagedClusterSetBindingController(
 	clusterClient clientset.Interface,
-	clusterSetInformer clusterinformerv1beta1.ManagedClusterSetInformer,
-	clusterSetBindingInformer clusterinformerv1beta1.ManagedClusterSetBindingInformer,
+	clusterSetInformer clusterinformerv1beta2.ManagedClusterSetInformer,
+	clusterSetBindingInformer clusterinformerv1beta2.ManagedClusterSetBindingInformer,
 	recorder events.Recorder) factory.Controller {
 
 	controllerName := "managed-clusterset-binding-controller"
@@ -86,7 +86,7 @@ func NewManagedClusterSetBindingController(
 }
 
 func indexByClusterset(obj interface{}) ([]string, error) {
-	binding, ok := obj.(*clusterv1beta1.ManagedClusterSetBinding)
+	binding, ok := obj.(*clusterv1beta2.ManagedClusterSetBinding)
 	if !ok {
 		return []string{}, fmt.Errorf("obj is supposed to be a ManagedClusterSetBinding, but is %T", obj)
 	}
@@ -94,15 +94,15 @@ func indexByClusterset(obj interface{}) ([]string, error) {
 	return []string{binding.Spec.ClusterSet}, nil
 }
 
-func (c *managedClusterSetBindingController) getClusterBindingsByClusterSet(name string) ([]*clusterv1beta1.ManagedClusterSetBinding, error) {
+func (c *managedClusterSetBindingController) getClusterBindingsByClusterSet(name string) ([]*clusterv1beta2.ManagedClusterSetBinding, error) {
 	objs, err := c.clusterSetBindingIndexers.ByIndex(byClusterSet, name)
 	if err != nil {
 		return nil, err
 	}
 
-	bindings := make([]*clusterv1beta1.ManagedClusterSetBinding, len(objs))
+	bindings := make([]*clusterv1beta2.ManagedClusterSetBinding, len(objs))
 	for _, obj := range objs {
-		binding := obj.(*clusterv1beta1.ManagedClusterSetBinding)
+		binding := obj.(*clusterv1beta2.ManagedClusterSetBinding)
 		bindings = append(bindings, binding)
 	}
 
@@ -163,7 +163,7 @@ func (c *managedClusterSetBindingController) sync(ctx context.Context, syncCtx f
 	switch {
 	case errors.IsNotFound(err):
 		meta.SetStatusCondition(&bindingCopy.Status.Conditions, metav1.Condition{
-			Type:   clusterv1beta1.ClusterSetBindingBoundType,
+			Type:   clusterv1beta2.ClusterSetBindingBoundType,
 			Status: metav1.ConditionFalse,
 			Reason: "ClusterSetNotFound",
 		})
@@ -173,7 +173,7 @@ func (c *managedClusterSetBindingController) sync(ctx context.Context, syncCtx f
 	}
 
 	meta.SetStatusCondition(&bindingCopy.Status.Conditions, metav1.Condition{
-		Type:   clusterv1beta1.ClusterSetBindingBoundType,
+		Type:   clusterv1beta2.ClusterSetBindingBoundType,
 		Status: metav1.ConditionTrue,
 		Reason: "ClusterSetBound",
 	})
@@ -181,13 +181,13 @@ func (c *managedClusterSetBindingController) sync(ctx context.Context, syncCtx f
 	return c.patchCondition(ctx, binding, bindingCopy)
 }
 
-func (c *managedClusterSetBindingController) patchCondition(ctx context.Context, old, new *clusterv1beta1.ManagedClusterSetBinding) error {
+func (c *managedClusterSetBindingController) patchCondition(ctx context.Context, old, new *clusterv1beta2.ManagedClusterSetBinding) error {
 	if equality.Semantic.DeepEqual(old.Status.Conditions, new.Status.Conditions) {
 		return nil
 	}
 
-	oldData, err := json.Marshal(clusterv1beta1.ManagedClusterSetBinding{
-		Status: clusterv1beta1.ManagedClusterSetBindingStatus{
+	oldData, err := json.Marshal(clusterv1beta2.ManagedClusterSetBinding{
+		Status: clusterv1beta2.ManagedClusterSetBindingStatus{
 			Conditions: old.Status.Conditions,
 		},
 	})
@@ -195,12 +195,12 @@ func (c *managedClusterSetBindingController) patchCondition(ctx context.Context,
 		return fmt.Errorf("failed to Marshal old data for workspace %s: %w", old.Name, err)
 	}
 
-	newData, err := json.Marshal(clusterv1beta1.ManagedClusterSetBinding{
+	newData, err := json.Marshal(clusterv1beta2.ManagedClusterSetBinding{
 		ObjectMeta: metav1.ObjectMeta{
 			UID:             old.UID,
 			ResourceVersion: old.ResourceVersion,
 		}, // to ensure they appear in the patch as preconditions
-		Status: clusterv1beta1.ManagedClusterSetBindingStatus{
+		Status: clusterv1beta2.ManagedClusterSetBindingStatus{
 			Conditions: new.Status.Conditions,
 		},
 	})
@@ -215,6 +215,6 @@ func (c *managedClusterSetBindingController) patchCondition(ctx context.Context,
 
 	c.eventRecorder.Eventf("PatchClusterSetBindingCondition", "patch clustersetbinding %s/%s condition", new.Namespace, new.Name)
 
-	_, err = c.clusterClient.ClusterV1beta1().ManagedClusterSetBindings(new.Namespace).Patch(ctx, new.Name, types.MergePatchType, patchBytes, metav1.PatchOptions{}, "status")
+	_, err = c.clusterClient.ClusterV1beta2().ManagedClusterSetBindings(new.Namespace).Patch(ctx, new.Name, types.MergePatchType, patchBytes, metav1.PatchOptions{}, "status")
 	return err
 }
diff --git a/pkg/hub/managedclustersetbinding/controller_test.go b/pkg/hub/managedclustersetbinding/controller_test.go
index a84857792..14d5f5890 100644
--- a/pkg/hub/managedclustersetbinding/controller_test.go
+++ b/pkg/hub/managedclustersetbinding/controller_test.go
@@ -14,7 +14,7 @@ import (
 	"k8s.io/client-go/tools/cache"
 	clusterfake "open-cluster-management.io/api/client/cluster/clientset/versioned/fake"
 	clusterinformers "open-cluster-management.io/api/client/cluster/informers/externalversions"
-	clusterv1beta1 "open-cluster-management.io/api/cluster/v1beta1"
+	clusterv1beta2 "open-cluster-management.io/api/cluster/v1beta2"
 	testinghelpers "open-cluster-management.io/registration/pkg/helpers/testing"
 )
 
@@ -22,7 +22,7 @@ func TestSync(t *testing.T) {
 	cases := []struct {
 		name              string
 		clusterSets       []runtime.Object
-		clusterSetBinding *clusterv1beta1.ManagedClusterSetBinding
+		clusterSetBinding *clusterv1beta2.ManagedClusterSetBinding
 		validateActions   func(t *testing.T, actions []clienttesting.Action)
 	}{
 		{
@@ -38,14 +38,14 @@ func TestSync(t *testing.T) {
 			validateActions: func(t *testing.T, actions []clienttesting.Action) {
 				testinghelpers.AssertActions(t, actions, "patch")
 				patchData := actions[0].(clienttesting.PatchActionImpl).Patch
-				binding := &clusterv1beta1.ManagedClusterSetBinding{}
+				binding := &clusterv1beta2.ManagedClusterSetBinding{}
 				err := json.Unmarshal(patchData, binding)
 				if err != nil {
 					t.Fatal(err)
 				}
 
 				testinghelpers.AssertCondition(t, binding.Status.Conditions, metav1.Condition{
-					Type:   clusterv1beta1.ClusterSetBindingBoundType,
+					Type:   clusterv1beta2.ClusterSetBindingBoundType,
 					Status: metav1.ConditionFalse,
 					Reason: "ClusterSetNotFound",
 				})
@@ -58,14 +58,14 @@ func TestSync(t *testing.T) {
 			validateActions: func(t *testing.T, actions []clienttesting.Action) {
 				testinghelpers.AssertActions(t, actions, "patch")
 				patchData := actions[0].(clienttesting.PatchActionImpl).Patch
-				binding := &clusterv1beta1.ManagedClusterSetBinding{}
+				binding := &clusterv1beta2.ManagedClusterSetBinding{}
 				err := json.Unmarshal(patchData, binding)
 				if err != nil {
 					t.Fatal(err)
 				}
 
 				testinghelpers.AssertCondition(t, binding.Status.Conditions, metav1.Condition{
-					Type:   clusterv1beta1.ClusterSetBindingBoundType,
+					Type:   clusterv1beta2.ClusterSetBindingBoundType,
 					Status: metav1.ConditionTrue,
 					Reason: "ClusterSetBound",
 				})
@@ -74,10 +74,10 @@ func TestSync(t *testing.T) {
 		{
 			name:        "no update",
 			clusterSets: []runtime.Object{newManagedClusterSet("test")},
-			clusterSetBinding: func() *clusterv1beta1.ManagedClusterSetBinding {
+			clusterSetBinding: func() *clusterv1beta2.ManagedClusterSetBinding {
 				binding := newManagedClusterSetBinding("test", "testns")
 				meta.SetStatusCondition(&binding.Status.Conditions, metav1.Condition{
-					Type:   clusterv1beta1.ClusterSetBindingBoundType,
+					Type:   clusterv1beta2.ClusterSetBindingBoundType,
 					Status: metav1.ConditionTrue,
 					Reason: "ClusterSetBound",
 				})
@@ -96,18 +96,18 @@ func TestSync(t *testing.T) {
 			clusterClient := clusterfake.NewSimpleClientset(objects...)
 			informerFactory := clusterinformers.NewSharedInformerFactory(clusterClient, 5*time.Minute)
 			for _, clusterset := range c.clusterSets {
-				if err := informerFactory.Cluster().V1beta1().ManagedClusterSets().Informer().GetStore().Add(clusterset); err != nil {
+				if err := informerFactory.Cluster().V1beta2().ManagedClusterSets().Informer().GetStore().Add(clusterset); err != nil {
 					t.Fatal(err)
 				}
 			}
-			if err := informerFactory.Cluster().V1beta1().ManagedClusterSetBindings().Informer().GetStore().Add(c.clusterSetBinding); err != nil {
+			if err := informerFactory.Cluster().V1beta2().ManagedClusterSetBindings().Informer().GetStore().Add(c.clusterSetBinding); err != nil {
 				t.Fatal(err)
 			}
 
 			ctrl := managedClusterSetBindingController{
 				clusterClient:           clusterClient,
-				clusterSetBindingLister: informerFactory.Cluster().V1beta1().ManagedClusterSetBindings().Lister(),
-				clusterSetLister:        informerFactory.Cluster().V1beta1().ManagedClusterSets().Lister(),
+				clusterSetBindingLister: informerFactory.Cluster().V1beta2().ManagedClusterSetBindings().Lister(),
+				clusterSetLister:        informerFactory.Cluster().V1beta2().ManagedClusterSets().Lister(),
 				eventRecorder:           eventstesting.NewTestingEventRecorder(t),
 			}
 
@@ -126,7 +126,7 @@ func TestSync(t *testing.T) {
 func TestEnqueue(t *testing.T) {
 	cases := []struct {
 		name               string
-		clusterSet         *clusterv1beta1.ManagedClusterSet
+		clusterSet         *clusterv1beta2.ManagedClusterSet
 		clusterSetBindings []runtime.Object
 		expectedQueueSize  int
 	}{
@@ -158,7 +158,7 @@ func TestEnqueue(t *testing.T) {
 
 			clusterClient := clusterfake.NewSimpleClientset(objects...)
 			informerFactory := clusterinformers.NewSharedInformerFactory(clusterClient, 5*time.Minute)
-			err := informerFactory.Cluster().V1beta1().ManagedClusterSetBindings().Informer().AddIndexers(cache.Indexers{
+			err := informerFactory.Cluster().V1beta2().ManagedClusterSetBindings().Informer().AddIndexers(cache.Indexers{
 				byClusterSet: indexByClusterset,
 			})
 
@@ -167,7 +167,7 @@ func TestEnqueue(t *testing.T) {
 			}
 
 			for _, binding := range c.clusterSetBindings {
-				if err := informerFactory.Cluster().V1beta1().ManagedClusterSetBindings().Informer().GetStore().Add(binding); err != nil {
+				if err := informerFactory.Cluster().V1beta2().ManagedClusterSetBindings().Informer().GetStore().Add(binding); err != nil {
 					t.Fatal(err)
 				}
 			}
@@ -175,7 +175,7 @@ func TestEnqueue(t *testing.T) {
 			syncCtx := testinghelpers.NewFakeSyncContext(t, "fake")
 
 			ctrl := managedClusterSetBindingController{
-				clusterSetBindingIndexers: informerFactory.Cluster().V1beta1().ManagedClusterSetBindings().Informer().GetIndexer(),
+				clusterSetBindingIndexers: informerFactory.Cluster().V1beta2().ManagedClusterSetBindings().Informer().GetIndexer(),
 				queue:                     syncCtx.Queue(),
 			}
 
@@ -188,8 +188,8 @@ func TestEnqueue(t *testing.T) {
 	}
 }
 
-func newManagedClusterSet(name string) *clusterv1beta1.ManagedClusterSet {
-	clusterSet := &clusterv1beta1.ManagedClusterSet{
+func newManagedClusterSet(name string) *clusterv1beta2.ManagedClusterSet {
+	clusterSet := &clusterv1beta2.ManagedClusterSet{
 		ObjectMeta: metav1.ObjectMeta{
 			Name: name,
 		},
@@ -198,13 +198,13 @@ func newManagedClusterSet(name string) *clusterv1beta1.ManagedClusterSet {
 	return clusterSet
 }
 
-func newManagedClusterSetBinding(name, namespace string) *clusterv1beta1.ManagedClusterSetBinding {
-	return &clusterv1beta1.ManagedClusterSetBinding{
+func newManagedClusterSetBinding(name, namespace string) *clusterv1beta2.ManagedClusterSetBinding {
+	return &clusterv1beta2.ManagedClusterSetBinding{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      name,
 			Namespace: namespace,
 		},
-		Spec: clusterv1beta1.ManagedClusterSetBindingSpec{
+		Spec: clusterv1beta2.ManagedClusterSetBindingSpec{
 			ClusterSet: name,
 		},
 	}
diff --git a/pkg/hub/manager.go b/pkg/hub/manager.go
index 12a0341fa..cddecd94c 100644
--- a/pkg/hub/manager.go
+++ b/pkg/hub/manager.go
@@ -132,14 +132,14 @@ func RunControllerManager(ctx context.Context, controllerContext *controllercmd.
 	managedClusterSetController := managedclusterset.NewManagedClusterSetController(
 		clusterClient,
 		clusterInformers.Cluster().V1().ManagedClusters(),
-		clusterInformers.Cluster().V1beta1().ManagedClusterSets(),
+		clusterInformers.Cluster().V1beta2().ManagedClusterSets(),
 		controllerContext.EventRecorder,
 	)
 
 	managedClusterSetBindingController := managedclustersetbinding.NewManagedClusterSetBindingController(
 		clusterClient,
-		clusterInformers.Cluster().V1beta1().ManagedClusterSets(),
-		clusterInformers.Cluster().V1beta1().ManagedClusterSetBindings(),
+		clusterInformers.Cluster().V1beta2().ManagedClusterSets(),
+		clusterInformers.Cluster().V1beta2().ManagedClusterSetBindings(),
 		controllerContext.EventRecorder,
 	)
 
@@ -167,13 +167,13 @@ func RunControllerManager(ctx context.Context, controllerContext *controllercmd.
 	var defaultManagedClusterSetController, globalManagedClusterSetController factory.Controller
 	if features.DefaultHubMutableFeatureGate.Enabled(ocmfeature.DefaultClusterSet) {
 		defaultManagedClusterSetController = managedclusterset.NewDefaultManagedClusterSetController(
-			clusterClient.ClusterV1beta1(),
-			clusterInformers.Cluster().V1beta1().ManagedClusterSets(),
+			clusterClient.ClusterV1beta2(),
+			clusterInformers.Cluster().V1beta2().ManagedClusterSets(),
 			controllerContext.EventRecorder,
 		)
 		globalManagedClusterSetController = managedclusterset.NewGlobalManagedClusterSetController(
-			clusterClient.ClusterV1beta1(),
-			clusterInformers.Cluster().V1beta1().ManagedClusterSets(),
+			clusterClient.ClusterV1beta2(),
+			clusterInformers.Cluster().V1beta2().ManagedClusterSets(),
 			controllerContext.EventRecorder,
 		)
 	}
diff --git a/pkg/webhook/cluster/mutating_webhook.go b/pkg/webhook/cluster/mutating_webhook.go
index 1f33b64a5..f227620be 100644
--- a/pkg/webhook/cluster/mutating_webhook.go
+++ b/pkg/webhook/cluster/mutating_webhook.go
@@ -4,10 +4,11 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
-	ocmfeature "open-cluster-management.io/api/feature"
 	"strings"
 	"time"
 
+	ocmfeature "open-cluster-management.io/api/feature"
+
 	admissionv1beta1 "k8s.io/api/admission/v1beta1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -15,7 +16,7 @@ import (
 	"k8s.io/client-go/rest"
 	"k8s.io/klog/v2"
 	clusterv1 "open-cluster-management.io/api/cluster/v1"
-	clusterv1beta1 "open-cluster-management.io/api/cluster/v1beta1"
+	clusterv1beta2 "open-cluster-management.io/api/cluster/v1beta1"
 	"open-cluster-management.io/registration/pkg/helpers"
 )
 
@@ -122,14 +123,14 @@ func (a *ManagedClusterMutatingAdmissionHook) addDefaultClusterSetLabel(managedC
 				Operation: "add",
 				Path:      "/metadata/labels",
 				Value: map[string]string{
-					clusterv1beta1.ClusterSetLabel: defaultClusterSetName,
+					clusterv1beta2.ClusterSetLabel: defaultClusterSetName,
 				},
 			},
 		}
 		return jsonPatches, status
 	}
 
-	clusterSetName, ok := managedCluster.Labels[clusterv1beta1.ClusterSetLabel]
+	clusterSetName, ok := managedCluster.Labels[clusterv1beta2.ClusterSetLabel]
 	// Clusterset label do not exist
 	if !ok {
 		jsonPatches = []jsonPatchOperation{
diff --git a/pkg/webhook/cluster/mutating_webhook_test.go b/pkg/webhook/cluster/mutating_webhook_test.go
index c656e07fd..23bd4899f 100644
--- a/pkg/webhook/cluster/mutating_webhook_test.go
+++ b/pkg/webhook/cluster/mutating_webhook_test.go
@@ -4,14 +4,15 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
-	ocmfeature "open-cluster-management.io/api/feature"
 	"reflect"
 	"testing"
 	"time"
 
+	ocmfeature "open-cluster-management.io/api/feature"
+
 	"github.com/openshift/library-go/pkg/operator/resource/resourcemerge"
 	clusterv1 "open-cluster-management.io/api/cluster/v1"
-	clusterv1beta1 "open-cluster-management.io/api/cluster/v1beta1"
+	clusterv1beta2 "open-cluster-management.io/api/cluster/v1beta2"
 
 	admissionv1beta1 "k8s.io/api/admission/v1beta1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -57,7 +58,7 @@ func TestManagedClusterMutate(t *testing.T) {
 					withLeaseDurationSeconds(60).
 					addTaint(newTaint("a", "b", clusterv1.TaintEffectNoSelect, nil)).
 					addTaint(newTaint("c", "d", clusterv1.TaintEffectPreferNoSelect, nil)).
-					addLabels(map[string]string{clusterv1beta1.ClusterSetLabel: defaultClusterSetName}).
+					addLabels(map[string]string{clusterv1beta2.ClusterSetLabel: defaultClusterSetName}).
 					build(),
 			},
 			expectedResponse: newAdmissionResponse(true).
@@ -74,7 +75,7 @@ func TestManagedClusterMutate(t *testing.T) {
 					withLeaseDurationSeconds(60).
 					addTaint(newTaint("a", "b", clusterv1.TaintEffectNoSelect, nil)).
 					addTaint(newTaint("c", "d", clusterv1.TaintEffectPreferNoSelect, newTime(now, 0))).
-					addLabels(map[string]string{clusterv1beta1.ClusterSetLabel: defaultClusterSetName}).
+					addLabels(map[string]string{clusterv1beta2.ClusterSetLabel: defaultClusterSetName}).
 					build(),
 			},
 			expectedResponse: newAdmissionResponse(true).
@@ -92,13 +93,13 @@ func TestManagedClusterMutate(t *testing.T) {
 					withLeaseDurationSeconds(60).
 					addTaint(newTaint("a", "b", clusterv1.TaintEffectNoSelect, newTime(now, -10*time.Second))).
 					addTaint(newTaint("c", "d", clusterv1.TaintEffectNoSelect, newTime(now, -10*time.Second))).
-					addLabels(map[string]string{clusterv1beta1.ClusterSetLabel: defaultClusterSetName}).
+					addLabels(map[string]string{clusterv1beta2.ClusterSetLabel: defaultClusterSetName}).
 					build(),
 				Object: newManagedCluster().
 					withLeaseDurationSeconds(60).
 					addTaint(newTaint("a", "b", clusterv1.TaintEffectNoSelect, newTime(now, -10*time.Second))). // no change
 					addTaint(newTaint("c", "d", clusterv1.TaintEffectNoSelectIfNew, nil)).                      // effect modified
-					addLabels(map[string]string{clusterv1beta1.ClusterSetLabel: defaultClusterSetName}).
+					addLabels(map[string]string{clusterv1beta2.ClusterSetLabel: defaultClusterSetName}).
 					build(),
 			},
 			expectedResponse: newAdmissionResponse(true).
@@ -134,12 +135,12 @@ func TestManagedClusterMutate(t *testing.T) {
 					withLeaseDurationSeconds(60).
 					addTaint(newTaint("a", "b", clusterv1.TaintEffectNoSelect, newTime(now, -10*time.Second))).
 					addTaint(newTaint("c", "d", clusterv1.TaintEffectNoSelect, newTime(now, -10*time.Second))).
-					addLabels(map[string]string{clusterv1beta1.ClusterSetLabel: defaultClusterSetName}).
+					addLabels(map[string]string{clusterv1beta2.ClusterSetLabel: defaultClusterSetName}).
 					build(),
 				Object: newManagedCluster().
 					withLeaseDurationSeconds(60).
 					addTaint(newTaint("a", "b", clusterv1.TaintEffectNoSelect, newTime(now, -10*time.Second))).
-					addLabels(map[string]string{clusterv1beta1.ClusterSetLabel: defaultClusterSetName}).
+					addLabels(map[string]string{clusterv1beta2.ClusterSetLabel: defaultClusterSetName}).
 					build(),
 			},
 			expectedResponse: newAdmissionResponse(true).build(),
@@ -158,7 +159,7 @@ func TestManagedClusterMutate(t *testing.T) {
 					Operation: "add",
 					Path:      "/metadata/labels",
 					Value: map[string]string{
-						clusterv1beta1.ClusterSetLabel: defaultClusterSetName,
+						clusterv1beta2.ClusterSetLabel: defaultClusterSetName,
 					},
 				}).
 				build(),
@@ -170,7 +171,7 @@ func TestManagedClusterMutate(t *testing.T) {
 				Operation: admissionv1beta1.Create,
 				Object: newManagedCluster().
 					withLeaseDurationSeconds(60).
-					addLabels(map[string]string{clusterv1beta1.ClusterSetLabel: "c1"}).
+					addLabels(map[string]string{clusterv1beta2.ClusterSetLabel: "c1"}).
 					build(),
 			},
 			expectedResponse: newAdmissionResponse(true).
@@ -183,7 +184,7 @@ func TestManagedClusterMutate(t *testing.T) {
 				Operation: admissionv1beta1.Create,
 				Object: newManagedCluster().
 					withLeaseDurationSeconds(60).
-					addLabels(map[string]string{clusterv1beta1.ClusterSetLabel: defaultClusterSetName}).
+					addLabels(map[string]string{clusterv1beta2.ClusterSetLabel: defaultClusterSetName}).
 					build(),
 			},
 			expectedResponse: newAdmissionResponse(true).
@@ -196,7 +197,7 @@ func TestManagedClusterMutate(t *testing.T) {
 				Operation: admissionv1beta1.Create,
 				Object: newManagedCluster().
 					withLeaseDurationSeconds(60).
-					addLabels(map[string]string{clusterv1beta1.ClusterSetLabel: ""}).
+					addLabels(map[string]string{clusterv1beta2.ClusterSetLabel: ""}).
 					build(),
 			},
 			expectedResponse: newAdmissionResponse(true).
diff --git a/pkg/webhook/cluster/validating_webhook.go b/pkg/webhook/cluster/validating_webhook.go
index 9f9cdbb70..453518c88 100644
--- a/pkg/webhook/cluster/validating_webhook.go
+++ b/pkg/webhook/cluster/validating_webhook.go
@@ -20,7 +20,7 @@ import (
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 	"k8s.io/klog/v2"
-	clusterv1beta1 "open-cluster-management.io/api/cluster/v1beta1"
+	clusterv1beta2 "open-cluster-management.io/api/cluster/v1beta1"
 )
 
 // ManagedClusterValidatingAdmissionHook will validate the creating/updating managedcluster request.
@@ -96,7 +96,7 @@ func (a *ManagedClusterValidatingAdmissionHook) validateCreateRequest(request *a
 	// check whether the request user has been allowed to set clusterset label
 	var clusterSetName string
 	if len(managedCluster.Labels) > 0 {
-		clusterSetName = managedCluster.Labels[clusterv1beta1.ClusterSetLabel]
+		clusterSetName = managedCluster.Labels[clusterv1beta2.ClusterSetLabel]
 	}
 
 	return a.allowSetClusterSetLabel(request.UserInfo, "", clusterSetName)
@@ -138,10 +138,10 @@ func (a *ManagedClusterValidatingAdmissionHook) validateUpdateRequest(request *a
 	// check whether the request user has been allowed to set clusterset label
 	var originalClusterSetName, currentClusterSetName string
 	if len(oldManagedCluster.Labels) > 0 {
-		originalClusterSetName = oldManagedCluster.Labels[clusterv1beta1.ClusterSetLabel]
+		originalClusterSetName = oldManagedCluster.Labels[clusterv1beta2.ClusterSetLabel]
 	}
 	if len(newManagedCluster.Labels) > 0 {
-		currentClusterSetName = newManagedCluster.Labels[clusterv1beta1.ClusterSetLabel]
+		currentClusterSetName = newManagedCluster.Labels[clusterv1beta2.ClusterSetLabel]
 	}
 
 	return a.allowSetClusterSetLabel(request.UserInfo, originalClusterSetName, currentClusterSetName)
diff --git a/pkg/webhook/cluster/validating_webhook_test.go b/pkg/webhook/cluster/validating_webhook_test.go
index 2596f9b27..c0e9829e7 100644
--- a/pkg/webhook/cluster/validating_webhook_test.go
+++ b/pkg/webhook/cluster/validating_webhook_test.go
@@ -7,7 +7,7 @@ import (
 	"testing"
 
 	clusterv1 "open-cluster-management.io/api/cluster/v1"
-	clusterv1beta1 "open-cluster-management.io/api/cluster/v1beta1"
+	clusterv1beta2 "open-cluster-management.io/api/cluster/v1beta2"
 	testinghelpers "open-cluster-management.io/registration/pkg/helpers/testing"
 
 	admissionv1beta1 "k8s.io/api/admission/v1beta1"
@@ -317,7 +317,7 @@ func newManagedClusterObjWithClientConfigs(clientConfig clusterv1.ClientConfig)
 func newManagedClusterObjWithClientSet(clusterSetName string) runtime.RawExtension {
 	managedCluster := testinghelpers.NewManagedCluster()
 	managedCluster.Labels = map[string]string{
-		clusterv1beta1.ClusterSetLabel: clusterSetName,
+		clusterv1beta2.ClusterSetLabel: clusterSetName,
 	}
 	clusterObj, _ := json.Marshal(managedCluster)
 	return runtime.RawExtension{
diff --git a/pkg/webhook/clustersetbinding/validating_webhook.go b/pkg/webhook/clustersetbinding/validating_webhook.go
index 2a824d4cc..7082013d9 100644
--- a/pkg/webhook/clustersetbinding/validating_webhook.go
+++ b/pkg/webhook/clustersetbinding/validating_webhook.go
@@ -14,7 +14,7 @@ import (
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 	"k8s.io/klog/v2"
-	clusterv1beta1 "open-cluster-management.io/api/cluster/v1beta1"
+	clusterv1beta2 "open-cluster-management.io/api/cluster/v1beta2"
 )
 
 // ManagedClusterSetBindingValidatingAdmissionHook will validate the creating/updating ManagedClusterSetBinding request.
@@ -48,7 +48,7 @@ func (a *ManagedClusterSetBindingValidatingAdmissionHook) Validate(admissionSpec
 		return acceptRequest()
 	}
 
-	binding := &clusterv1beta1.ManagedClusterSetBinding{}
+	binding := &clusterv1beta2.ManagedClusterSetBinding{}
 	if err := json.Unmarshal(admissionSpec.Object.Raw, binding); err != nil {
 		return denyRequest(http.StatusBadRequest, metav1.StatusReasonBadRequest,
 			fmt.Sprintf("Unable to unmarshal the ManagedClusterSetBinding object: %v", err))
diff --git a/pkg/webhook/clustersetbinding/validating_webhook_test.go b/pkg/webhook/clustersetbinding/validating_webhook_test.go
index 933e6d03d..b5869b1f8 100644
--- a/pkg/webhook/clustersetbinding/validating_webhook_test.go
+++ b/pkg/webhook/clustersetbinding/validating_webhook_test.go
@@ -12,7 +12,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	kubefake "k8s.io/client-go/kubernetes/fake"
 	clienttesting "k8s.io/client-go/testing"
-	clusterv1beta1 "open-cluster-management.io/api/cluster/v1beta1"
+	clusterv1beta2 "open-cluster-management.io/api/cluster/v1beta2"
 )
 
 var managedclustersetbindingSchema = metav1.GroupVersionResource{
@@ -154,13 +154,13 @@ func TestManagedClusterValidate(t *testing.T) {
 }
 
 func newManagedClusterSetBindingObj(namespace, name, clusterSetName string, labels map[string]string) runtime.RawExtension {
-	managedClusterSetBinding := &clusterv1beta1.ManagedClusterSetBinding{
+	managedClusterSetBinding := &clusterv1beta2.ManagedClusterSetBinding{
 		ObjectMeta: metav1.ObjectMeta{
 			Namespace: namespace,
 			Name:      name,
 			Labels:    labels,
 		},
-		Spec: clusterv1beta1.ManagedClusterSetBindingSpec{
+		Spec: clusterv1beta2.ManagedClusterSetBindingSpec{
 			ClusterSet: clusterSetName,
 		},
 	}
diff --git a/test/e2e/managedclustersetbinding_test.go b/test/e2e/managedclustersetbinding_test.go
index 08ec30c31..70c87f35c 100644
--- a/test/e2e/managedclustersetbinding_test.go
+++ b/test/e2e/managedclustersetbinding_test.go
@@ -12,7 +12,7 @@ import (
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/rand"
-	clusterv1beta1 "open-cluster-management.io/api/cluster/v1beta1"
+	clusterv1beta2 "open-cluster-management.io/api/cluster/v1beta2"
 )
 
 var _ = ginkgo.Describe("ManagedClusterSetBinding", func() {
@@ -34,11 +34,11 @@ var _ = ginkgo.Describe("ManagedClusterSetBinding", func() {
 			gomega.Eventually(func() error {
 				clusterSetName := fmt.Sprintf("clusterset-%s", rand.String(6))
 				managedClusterSetBinding := newManagedClusterSetBinding(namespace, clusterSetName, clusterSetName)
-				_, err := clusterClient.ClusterV1beta1().ManagedClusterSetBindings(namespace).Create(context.TODO(), managedClusterSetBinding, metav1.CreateOptions{})
+				_, err := clusterClient.ClusterV1beta2().ManagedClusterSetBindings(namespace).Create(context.TODO(), managedClusterSetBinding, metav1.CreateOptions{})
 				if err != nil {
 					return err
 				}
-				return clusterClient.ClusterV1beta1().ManagedClusterSetBindings(namespace).Delete(context.TODO(), clusterSetName, metav1.DeleteOptions{})
+				return clusterClient.ClusterV1beta2().ManagedClusterSetBindings(namespace).Delete(context.TODO(), clusterSetName, metav1.DeleteOptions{})
 			}, 60*time.Second, 1*time.Second).Should(gomega.Succeed())
 		})
 
@@ -53,55 +53,55 @@ var _ = ginkgo.Describe("ManagedClusterSetBinding", func() {
 		ginkgo.It("should bound a ManagedClusterSetBinding", func() {
 			clusterSetName := fmt.Sprintf("clusterset-%s", rand.String(6))
 			managedClusterSetBinding := newManagedClusterSetBinding(namespace, clusterSetName, clusterSetName)
-			_, err := clusterClient.ClusterV1beta1().ManagedClusterSetBindings(namespace).Create(context.TODO(), managedClusterSetBinding, metav1.CreateOptions{})
+			_, err := clusterClient.ClusterV1beta2().ManagedClusterSetBindings(namespace).Create(context.TODO(), managedClusterSetBinding, metav1.CreateOptions{})
 			gomega.Expect(err).ToNot(gomega.HaveOccurred())
 
 			// make sure the managedclustersetbinding status is correct
 			gomega.Eventually(func() error {
-				binding, err := clusterClient.ClusterV1beta1().ManagedClusterSetBindings(namespace).Get(context.TODO(), clusterSetName, metav1.GetOptions{})
+				binding, err := clusterClient.ClusterV1beta2().ManagedClusterSetBindings(namespace).Get(context.TODO(), clusterSetName, metav1.GetOptions{})
 				if err != nil {
 					return err
 				}
 
-				if !meta.IsStatusConditionFalse(binding.Status.Conditions, clusterv1beta1.ClusterSetBindingBoundType) {
+				if !meta.IsStatusConditionFalse(binding.Status.Conditions, clusterv1beta2.ClusterSetBindingBoundType) {
 					return fmt.Errorf("binding %s/%s condition should be false", namespace, clusterSetName)
 				}
 				return nil
 			}, 60*time.Second, 1*time.Second).Should(gomega.Succeed())
 
-			managedClusterSet := &clusterv1beta1.ManagedClusterSet{
+			managedClusterSet := &clusterv1beta2.ManagedClusterSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name: clusterSetName,
 				},
 			}
 
-			_, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Create(context.TODO(), managedClusterSet, metav1.CreateOptions{})
+			_, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Create(context.TODO(), managedClusterSet, metav1.CreateOptions{})
 			gomega.Expect(err).ToNot(gomega.HaveOccurred())
 
 			// make sure the managedclustersetbinding status is correct
 			gomega.Eventually(func() error {
-				binding, err := clusterClient.ClusterV1beta1().ManagedClusterSetBindings(namespace).Get(context.TODO(), clusterSetName, metav1.GetOptions{})
+				binding, err := clusterClient.ClusterV1beta2().ManagedClusterSetBindings(namespace).Get(context.TODO(), clusterSetName, metav1.GetOptions{})
 				if err != nil {
 					return err
 				}
 
-				if !meta.IsStatusConditionTrue(binding.Status.Conditions, clusterv1beta1.ClusterSetBindingBoundType) {
+				if !meta.IsStatusConditionTrue(binding.Status.Conditions, clusterv1beta2.ClusterSetBindingBoundType) {
 					return fmt.Errorf("binding %s/%s condition should be true", namespace, clusterSetName)
 				}
 				return nil
 			}, 60*time.Second, 1*time.Second).Should(gomega.Succeed())
 
-			err = clusterClient.ClusterV1beta1().ManagedClusterSets().Delete(context.TODO(), clusterSetName, metav1.DeleteOptions{})
+			err = clusterClient.ClusterV1beta2().ManagedClusterSets().Delete(context.TODO(), clusterSetName, metav1.DeleteOptions{})
 			gomega.Expect(err).ToNot(gomega.HaveOccurred())
 
 			// make sure the managedclustersetbinding status is correct
 			gomega.Eventually(func() error {
-				binding, err := clusterClient.ClusterV1beta1().ManagedClusterSetBindings(namespace).Get(context.TODO(), clusterSetName, metav1.GetOptions{})
+				binding, err := clusterClient.ClusterV1beta2().ManagedClusterSetBindings(namespace).Get(context.TODO(), clusterSetName, metav1.GetOptions{})
 				if err != nil {
 					return err
 				}
 
-				if !meta.IsStatusConditionFalse(binding.Status.Conditions, clusterv1beta1.ClusterSetBindingBoundType) {
+				if !meta.IsStatusConditionFalse(binding.Status.Conditions, clusterv1beta2.ClusterSetBindingBoundType) {
 					return fmt.Errorf("binding %s/%s condition should be false", namespace, clusterSetName)
 				}
 				return nil
diff --git a/test/e2e/webhook_test.go b/test/e2e/webhook_test.go
index 5e905a028..c69d37011 100644
--- a/test/e2e/webhook_test.go
+++ b/test/e2e/webhook_test.go
@@ -11,7 +11,6 @@ import (
 
 	clusterv1client "open-cluster-management.io/api/client/cluster/clientset/versioned"
 	clusterv1 "open-cluster-management.io/api/cluster/v1"
-	clusterv1beta1 "open-cluster-management.io/api/cluster/v1beta1"
 	clusterv1beta2 "open-cluster-management.io/api/cluster/v1beta2"
 
 	corev1 "k8s.io/api/core/v1"
@@ -86,7 +85,7 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 				managedCluster, err := clusterClient.ClusterV1().ManagedClusters().Get(context.TODO(), clusterName, metav1.GetOptions{})
 				gomega.Expect(err).ToNot(gomega.HaveOccurred())
 
-				gomega.Expect(managedCluster.Labels[clusterv1beta1.ClusterSetLabel]).To(gomega.Equal(string(defaultClusterSetName)))
+				gomega.Expect(managedCluster.Labels[clusterv1beta2.ClusterSetLabel]).To(gomega.Equal(string(defaultClusterSetName)))
 
 				gomega.Expect(len(managedCluster.Labels)).To(gomega.Equal(len(oriManagedCluster.Labels) + 1))
 				gomega.Expect(u.deleteManageClusterAndRelatedNamespace(clusterName)).ToNot(gomega.HaveOccurred())
@@ -105,7 +104,7 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 				managedCluster, err := clusterClient.ClusterV1().ManagedClusters().Get(context.TODO(), clusterName, metav1.GetOptions{})
 				gomega.Expect(err).ToNot(gomega.HaveOccurred())
 
-				gomega.Expect(managedCluster.Labels[clusterv1beta1.ClusterSetLabel]).To(gomega.Equal(string(defaultClusterSetName)))
+				gomega.Expect(managedCluster.Labels[clusterv1beta2.ClusterSetLabel]).To(gomega.Equal(string(defaultClusterSetName)))
 
 				gomega.Expect(len(managedCluster.Labels)).To(gomega.Equal(len(oriManagedCluster.Labels) + 1))
 				gomega.Expect(u.deleteManageClusterAndRelatedNamespace(clusterName)).ToNot(gomega.HaveOccurred())
@@ -116,7 +115,7 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 				oriManagedCluster := newManagedCluster(clusterName, false, validURL)
 
 				oriManagedCluster.Labels = map[string]string{
-					clusterv1beta1.ClusterSetLabel: "",
+					clusterv1beta2.ClusterSetLabel: "",
 				}
 				_, err := clusterClient.ClusterV1().ManagedClusters().Create(context.TODO(), oriManagedCluster, metav1.CreateOptions{})
 				gomega.Expect(err).ToNot(gomega.HaveOccurred())
@@ -124,7 +123,7 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 				managedCluster, err := clusterClient.ClusterV1().ManagedClusters().Get(context.TODO(), clusterName, metav1.GetOptions{})
 				gomega.Expect(err).ToNot(gomega.HaveOccurred())
 
-				gomega.Expect(managedCluster.Labels[clusterv1beta1.ClusterSetLabel]).To(gomega.Equal(string(defaultClusterSetName)))
+				gomega.Expect(managedCluster.Labels[clusterv1beta2.ClusterSetLabel]).To(gomega.Equal(string(defaultClusterSetName)))
 			})
 			ginkgo.It("Should have the timeAdded for taints", func() {
 				clusterName := fmt.Sprintf("webhook-spoke-%s", rand.String(6))
@@ -280,6 +279,9 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 				managedCluster := newManagedCluster(clusterName, true, validURL)
 				managedCluster, err = clusterClient.ClusterV1().ManagedClusters().Create(context.TODO(), managedCluster, metav1.CreateOptions{})
 				gomega.Expect(err).ToNot(gomega.HaveOccurred())
+
+				managedCluster, err = clusterClient.ClusterV1().ManagedClusters().Get(context.TODO(), managedCluster.Name, metav1.GetOptions{})
+				gomega.Expect(err).ToNot(gomega.HaveOccurred())
 				updatedManagedCluster := managedCluster.DeepCopy()
 				updatedManagedCluster.Labels = map[string]string{
 					"k": "v",
@@ -294,13 +296,13 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 				clusterSetName := fmt.Sprintf("webhook-spoke-%s", rand.String(6))
 				ginkgo.By(fmt.Sprintf("create a managed cluster set %q", clusterSetName))
 
-				managedClusterSet := &clusterv1beta1.ManagedClusterSet{
+				managedClusterSet := &clusterv1beta2.ManagedClusterSet{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: clusterSetName,
 					},
 				}
 
-				_, err := clusterClient.ClusterV1beta1().ManagedClusterSets().Create(context.TODO(), managedClusterSet, metav1.CreateOptions{})
+				_, err := clusterClient.ClusterV1beta2().ManagedClusterSets().Create(context.TODO(), managedClusterSet, metav1.CreateOptions{})
 				gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 				sa := fmt.Sprintf("webhook-sa-%s", rand.String(6))
@@ -324,7 +326,7 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 
 				managedCluster := newManagedCluster(clusterName, false, validURL)
 				managedCluster.Labels = map[string]string{
-					clusterv1beta1.ClusterSetLabel: clusterSetName,
+					clusterv1beta2.ClusterSetLabel: clusterSetName,
 				}
 				_, err = authorizedClient.ClusterV1().ManagedClusters().Create(context.TODO(), managedCluster, metav1.CreateOptions{})
 				gomega.Expect(err).ToNot(gomega.HaveOccurred())
@@ -337,13 +339,13 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 				clusterSetName := fmt.Sprintf("webhook-spoke-%s", rand.String(6))
 				ginkgo.By(fmt.Sprintf("create a managed cluster set %q", clusterSetName))
 
-				managedClusterSet := &clusterv1beta1.ManagedClusterSet{
+				managedClusterSet := &clusterv1beta2.ManagedClusterSet{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: clusterSetName,
 					},
 				}
 
-				_, err := clusterClient.ClusterV1beta1().ManagedClusterSets().Create(context.TODO(), managedClusterSet, metav1.CreateOptions{})
+				_, err := clusterClient.ClusterV1beta2().ManagedClusterSets().Create(context.TODO(), managedClusterSet, metav1.CreateOptions{})
 				gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 				sa := fmt.Sprintf("webhook-sa-%s", rand.String(6))
@@ -364,7 +366,7 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 
 				managedCluster := newManagedCluster(clusterName, false, validURL)
 				managedCluster.Labels = map[string]string{
-					clusterv1beta1.ClusterSetLabel: clusterSetName,
+					clusterv1beta2.ClusterSetLabel: clusterSetName,
 				}
 				_, err = unauthorizedClient.ClusterV1().ManagedClusters().Create(context.TODO(), managedCluster, metav1.CreateOptions{})
 				gomega.Expect(err).To(gomega.HaveOccurred())
@@ -412,7 +414,7 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 					managedCluster, err := clusterClient.ClusterV1().ManagedClusters().Get(context.TODO(), clusterName, metav1.GetOptions{})
 					gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-					delete(managedCluster.Labels, clusterv1beta1.ClusterSetLabel)
+					delete(managedCluster.Labels, clusterv1beta2.ClusterSetLabel)
 					_, err = clusterClient.ClusterV1().ManagedClusters().Update(context.TODO(), managedCluster, metav1.UpdateOptions{})
 					return err
 				})
@@ -420,7 +422,7 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 
 				managedCluster, err := clusterClient.ClusterV1().ManagedClusters().Get(context.TODO(), clusterName, metav1.GetOptions{})
 				gomega.Expect(err).ToNot(gomega.HaveOccurred())
-				gomega.Expect(managedCluster.Labels[clusterv1beta1.ClusterSetLabel]).To(gomega.Equal(string(defaultClusterSetName)))
+				gomega.Expect(managedCluster.Labels[clusterv1beta2.ClusterSetLabel]).To(gomega.Equal(string(defaultClusterSetName)))
 			})
 
 			ginkgo.It("Should not update the other ClusterSet Label", func() {
@@ -429,7 +431,7 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 					managedCluster, err := clusterClient.ClusterV1().ManagedClusters().Get(context.TODO(), clusterName, metav1.GetOptions{})
 					gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-					managedCluster.Labels[clusterv1beta1.ClusterSetLabel] = "s1"
+					managedCluster.Labels[clusterv1beta2.ClusterSetLabel] = "s1"
 
 					_, err = clusterClient.ClusterV1().ManagedClusters().Update(context.TODO(), managedCluster, metav1.UpdateOptions{})
 					return err
@@ -438,7 +440,7 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 
 				managedCluster, err := clusterClient.ClusterV1().ManagedClusters().Get(context.TODO(), clusterName, metav1.GetOptions{})
 				gomega.Expect(err).ToNot(gomega.HaveOccurred())
-				gomega.Expect(managedCluster.Labels[clusterv1beta1.ClusterSetLabel]).To(gomega.Equal("s1"))
+				gomega.Expect(managedCluster.Labels[clusterv1beta2.ClusterSetLabel]).To(gomega.Equal("s1"))
 			})
 
 			ginkgo.It("Should respond bad request when updating a managed cluster with invalid external server URLs", func() {
@@ -489,13 +491,13 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 				clusterSetName := fmt.Sprintf("webhook-spoke-%s", rand.String(6))
 				ginkgo.By(fmt.Sprintf("create a managed cluster set %q", clusterSetName))
 
-				managedClusterSet := &clusterv1beta1.ManagedClusterSet{
+				managedClusterSet := &clusterv1beta2.ManagedClusterSet{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: clusterSetName,
 					},
 				}
 
-				_, err := clusterClient.ClusterV1beta1().ManagedClusterSets().Create(context.TODO(), managedClusterSet, metav1.CreateOptions{})
+				_, err := clusterClient.ClusterV1beta2().ManagedClusterSets().Create(context.TODO(), managedClusterSet, metav1.CreateOptions{})
 				gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 				sa := fmt.Sprintf("webhook-sa-%s", rand.String(6))
@@ -520,7 +522,7 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 					gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 					managedCluster.Labels = map[string]string{
-						clusterv1beta1.ClusterSetLabel: clusterSetName,
+						clusterv1beta2.ClusterSetLabel: clusterSetName,
 					}
 					_, err = authorizedClient.ClusterV1().ManagedClusters().Update(context.TODO(), managedCluster, metav1.UpdateOptions{})
 					return err
@@ -534,13 +536,13 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 				clusterSetName := fmt.Sprintf("webhook-spoke-%s", rand.String(6))
 				ginkgo.By(fmt.Sprintf("create a managed cluster set %q", clusterSetName))
 
-				managedClusterSet := &clusterv1beta1.ManagedClusterSet{
+				managedClusterSet := &clusterv1beta2.ManagedClusterSet{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: clusterSetName,
 					},
 				}
 
-				_, err := clusterClient.ClusterV1beta1().ManagedClusterSets().Create(context.TODO(), managedClusterSet, metav1.CreateOptions{})
+				_, err := clusterClient.ClusterV1beta2().ManagedClusterSets().Create(context.TODO(), managedClusterSet, metav1.CreateOptions{})
 				gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 				sa := fmt.Sprintf("webhook-sa-%s", rand.String(6))
@@ -568,7 +570,7 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 					gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 					managedCluster.Labels = map[string]string{
-						clusterv1beta1.ClusterSetLabel: clusterSetName,
+						clusterv1beta2.ClusterSetLabel: clusterSetName,
 					}
 					_, err = unauthorizedClient.ClusterV1().ManagedClusters().Update(context.TODO(), managedCluster, metav1.UpdateOptions{})
 					return err
@@ -601,11 +603,11 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 			gomega.Eventually(func() error {
 				clusterSetName := fmt.Sprintf("clusterset-%s", rand.String(6))
 				managedClusterSetBinding := newManagedClusterSetBinding(namespace, clusterSetName, clusterSetName)
-				_, err := clusterClient.ClusterV1beta1().ManagedClusterSetBindings(namespace).Create(context.TODO(), managedClusterSetBinding, metav1.CreateOptions{})
+				_, err := clusterClient.ClusterV1beta2().ManagedClusterSetBindings(namespace).Create(context.TODO(), managedClusterSetBinding, metav1.CreateOptions{})
 				if err != nil {
 					return err
 				}
-				return clusterClient.ClusterV1beta1().ManagedClusterSetBindings(namespace).Delete(context.TODO(), clusterSetName, metav1.DeleteOptions{})
+				return clusterClient.ClusterV1beta2().ManagedClusterSetBindings(namespace).Delete(context.TODO(), clusterSetName, metav1.DeleteOptions{})
 			}, 60*time.Second, 1*time.Second).Should(gomega.Succeed())
 		})
 
@@ -622,7 +624,7 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 				clusterSetName := fmt.Sprintf("clusterset-%s", rand.String(6))
 				clusterSetBindingName := fmt.Sprintf("clustersetbinding-%s", rand.String(6))
 				managedClusterSetBinding := newManagedClusterSetBinding(namespace, clusterSetBindingName, clusterSetName)
-				_, err := clusterClient.ClusterV1beta1().ManagedClusterSetBindings(namespace).Create(context.TODO(), managedClusterSetBinding, metav1.CreateOptions{})
+				_, err := clusterClient.ClusterV1beta2().ManagedClusterSetBindings(namespace).Create(context.TODO(), managedClusterSetBinding, metav1.CreateOptions{})
 				gomega.Expect(err).To(gomega.HaveOccurred())
 				gomega.Expect(errors.IsBadRequest(err)).Should(gomega.BeTrue())
 			})
@@ -647,7 +649,7 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 				gomega.Expect(err).ToNot(gomega.HaveOccurred())
 
 				managedClusterSetBinding := newManagedClusterSetBinding(namespace, clusterSetName, clusterSetName)
-				_, err = authorizedClient.ClusterV1beta1().ManagedClusterSetBindings(namespace).Create(context.TODO(), managedClusterSetBinding, metav1.CreateOptions{})
+				_, err = authorizedClient.ClusterV1beta2().ManagedClusterSetBindings(namespace).Create(context.TODO(), managedClusterSetBinding, metav1.CreateOptions{})
 				gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 				gomega.Expect(cleanupClusterClient(namespace, sa)).ToNot(gomega.HaveOccurred())
@@ -669,7 +671,7 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 				gomega.Expect(err).ToNot(gomega.HaveOccurred())
 
 				managedClusterSetBinding := newManagedClusterSetBinding(namespace, clusterSetName, clusterSetName)
-				_, err = unauthorizedClient.ClusterV1beta1().ManagedClusterSetBindings(namespace).Create(context.TODO(), managedClusterSetBinding, metav1.CreateOptions{})
+				_, err = unauthorizedClient.ClusterV1beta2().ManagedClusterSetBindings(namespace).Create(context.TODO(), managedClusterSetBinding, metav1.CreateOptions{})
 				gomega.Expect(err).To(gomega.HaveOccurred())
 				gomega.Expect(errors.IsForbidden(err)).Should(gomega.BeTrue())
 
@@ -682,13 +684,13 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 				// create a cluster set binding
 				clusterSetName := fmt.Sprintf("clusterset-%s", rand.String(6))
 				managedClusterSetBinding := newManagedClusterSetBinding(namespace, clusterSetName, clusterSetName)
-				managedClusterSetBinding, err := clusterClient.ClusterV1beta1().ManagedClusterSetBindings(namespace).Create(context.TODO(), managedClusterSetBinding, metav1.CreateOptions{})
+				managedClusterSetBinding, err := clusterClient.ClusterV1beta2().ManagedClusterSetBindings(namespace).Create(context.TODO(), managedClusterSetBinding, metav1.CreateOptions{})
 				gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 				// update the cluster set binding
 				clusterSetName = fmt.Sprintf("clusterset-%s", rand.String(6))
 				patch := fmt.Sprintf("{\"spec\": {\"clusterSet\": %q}}", clusterSetName)
-				_, err = clusterClient.ClusterV1beta1().ManagedClusterSetBindings(namespace).Patch(context.TODO(), managedClusterSetBinding.Name, types.MergePatchType, []byte(patch), metav1.PatchOptions{})
+				_, err = clusterClient.ClusterV1beta2().ManagedClusterSetBindings(namespace).Patch(context.TODO(), managedClusterSetBinding.Name, types.MergePatchType, []byte(patch), metav1.PatchOptions{})
 				gomega.Expect(err).To(gomega.HaveOccurred())
 				gomega.Expect(errors.IsBadRequest(err)).Should(gomega.BeTrue())
 			})
@@ -697,7 +699,7 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 				// create a cluster set binding
 				clusterSetName := fmt.Sprintf("clusterset-%s", rand.String(6))
 				managedClusterSetBinding := newManagedClusterSetBinding(namespace, clusterSetName, clusterSetName)
-				_, err := clusterClient.ClusterV1beta1().ManagedClusterSetBindings(namespace).Create(context.TODO(), managedClusterSetBinding, metav1.CreateOptions{})
+				_, err := clusterClient.ClusterV1beta2().ManagedClusterSetBindings(namespace).Create(context.TODO(), managedClusterSetBinding, metav1.CreateOptions{})
 				gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 				// create a client without clusterset binding permission
@@ -713,12 +715,12 @@ var _ = ginkgo.Describe("Admission webhook", func() {
 
 				// update the cluster set binding by unauthorized user
 				gomega.Eventually(func() error {
-					binding, err := unauthorizedClient.ClusterV1beta1().ManagedClusterSetBindings(namespace).Get(context.TODO(), clusterSetName, metav1.GetOptions{})
+					binding, err := unauthorizedClient.ClusterV1beta2().ManagedClusterSetBindings(namespace).Get(context.TODO(), clusterSetName, metav1.GetOptions{})
 					if err != nil {
 						return err
 					}
 					binding.Labels = map[string]string{"owner": "user"}
-					_, err = unauthorizedClient.ClusterV1beta1().ManagedClusterSetBindings(namespace).Update(context.TODO(), binding, metav1.UpdateOptions{})
+					_, err = unauthorizedClient.ClusterV1beta2().ManagedClusterSetBindings(namespace).Update(context.TODO(), binding, metav1.UpdateOptions{})
 					return err
 				}, 60*time.Second, 1*time.Second).Should(gomega.Succeed())
 			})
@@ -851,13 +853,13 @@ func newManagedCluster(name string, accepted bool, externalURL string) *clusterv
 	}
 }
 
-func newManagedClusterSetBinding(namespace, name string, clusterSet string) *clusterv1beta1.ManagedClusterSetBinding {
-	return &clusterv1beta1.ManagedClusterSetBinding{
+func newManagedClusterSetBinding(namespace, name string, clusterSet string) *clusterv1beta2.ManagedClusterSetBinding {
+	return &clusterv1beta2.ManagedClusterSetBinding{
 		ObjectMeta: metav1.ObjectMeta{
 			Namespace: namespace,
 			Name:      name,
 		},
-		Spec: clusterv1beta1.ManagedClusterSetBindingSpec{
+		Spec: clusterv1beta2.ManagedClusterSetBindingSpec{
 			ClusterSet: clusterSet,
 		},
 	}
diff --git a/test/integration/default_managedclusterset_controller_test.go b/test/integration/default_managedclusterset_controller_test.go
index 7112e1f0b..14e196020 100644
--- a/test/integration/default_managedclusterset_controller_test.go
+++ b/test/integration/default_managedclusterset_controller_test.go
@@ -18,7 +18,7 @@ var _ = ginkgo.Describe("DefaultManagedClusterSet", func() {
 
 		ginkgo.By("check whether DefaultManagedClusterSet is created")
 		gomega.Eventually(func() error {
-			mcs, err := clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.TODO(), setcontroller.DefaultManagedClusterSetName, metav1.GetOptions{})
+			mcs, err := clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.TODO(), setcontroller.DefaultManagedClusterSetName, metav1.GetOptions{})
 			if err != nil {
 				return err
 			}
@@ -34,12 +34,12 @@ var _ = ginkgo.Describe("DefaultManagedClusterSet", func() {
 	ginkgo.It("should recreate DefaultManagedClusterSet successfully after deleted", func() {
 
 		ginkgo.By("delete DefaultManagedClusterSet")
-		err := clusterClient.ClusterV1beta1().ManagedClusterSets().Delete(context.TODO(), setcontroller.DefaultManagedClusterSetName, metav1.DeleteOptions{})
+		err := clusterClient.ClusterV1beta2().ManagedClusterSets().Delete(context.TODO(), setcontroller.DefaultManagedClusterSetName, metav1.DeleteOptions{})
 		gomega.Expect(err).NotTo(gomega.HaveOccurred(), "try to delete DefaultManagedClusterSet error")
 
 		ginkgo.By("check whether DefaultManagedClusterSet is recreated")
 		gomega.Eventually(func() error {
-			mcs, err := clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.TODO(), setcontroller.DefaultManagedClusterSetName, metav1.GetOptions{})
+			mcs, err := clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.TODO(), setcontroller.DefaultManagedClusterSetName, metav1.GetOptions{})
 			if err != nil {
 				return err
 			}
diff --git a/test/integration/global_managedclusterset_controller_test.go b/test/integration/global_managedclusterset_controller_test.go
index e3904e607..0d42fe660 100644
--- a/test/integration/global_managedclusterset_controller_test.go
+++ b/test/integration/global_managedclusterset_controller_test.go
@@ -17,7 +17,7 @@ var _ = ginkgo.Describe("GlobalManagedClusterSet", func() {
 	ginkgo.It("should create GlobalManagedClusterSet successfully", func() {
 		ginkgo.By("check whether GlobalManagedClusterSet is created")
 		gomega.Eventually(func() error {
-			mcs, err := clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.TODO(), setcontroller.GlobalManagedClusterSetName, metav1.GetOptions{})
+			mcs, err := clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.TODO(), setcontroller.GlobalManagedClusterSetName, metav1.GetOptions{})
 			if err != nil {
 				return err
 			}
@@ -32,7 +32,7 @@ var _ = ginkgo.Describe("GlobalManagedClusterSet", func() {
 
 	ginkgo.It("should reconcile GlobalManagedClusterSet successfully if it changed", func() {
 		ginkgo.By("check whether GlobalManagedClusterSet is reconciled after changed")
-		mcs, err := clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.TODO(), setcontroller.GlobalManagedClusterSetName, metav1.GetOptions{})
+		mcs, err := clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.TODO(), setcontroller.GlobalManagedClusterSetName, metav1.GetOptions{})
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 		updateMcs := mcs.DeepCopy()
@@ -41,11 +41,11 @@ var _ = ginkgo.Describe("GlobalManagedClusterSet", func() {
 				"vendor": "openshift",
 			},
 		}
-		_, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Update(context.TODO(), updateMcs, metav1.UpdateOptions{})
+		_, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Update(context.TODO(), updateMcs, metav1.UpdateOptions{})
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 		gomega.Eventually(func() error {
-			mcs, err := clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.TODO(), setcontroller.GlobalManagedClusterSetName, metav1.GetOptions{})
+			mcs, err := clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.TODO(), setcontroller.GlobalManagedClusterSetName, metav1.GetOptions{})
 			if err != nil {
 				return err
 			}
@@ -58,7 +58,7 @@ var _ = ginkgo.Describe("GlobalManagedClusterSet", func() {
 
 	ginkgo.It("should not change users labels/annotations in GlobalManagedClusterSet", func() {
 		ginkgo.By("check whether GlobalManagedClusterSet labels/annotations reconciled after changed")
-		mcs, err := clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.TODO(), setcontroller.GlobalManagedClusterSetName, metav1.GetOptions{})
+		mcs, err := clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.TODO(), setcontroller.GlobalManagedClusterSetName, metav1.GetOptions{})
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 		updateMcs := mcs.DeepCopy()
@@ -73,11 +73,11 @@ var _ = ginkgo.Describe("GlobalManagedClusterSet", func() {
 				"vendor": "openshift",
 			},
 		}
-		_, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Update(context.TODO(), updateMcs, metav1.UpdateOptions{})
+		_, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Update(context.TODO(), updateMcs, metav1.UpdateOptions{})
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 		gomega.Eventually(func() error {
-			mcs, err := clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.TODO(), setcontroller.GlobalManagedClusterSetName, metav1.GetOptions{})
+			mcs, err := clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.TODO(), setcontroller.GlobalManagedClusterSetName, metav1.GetOptions{})
 			if err != nil {
 				return err
 			}
@@ -90,12 +90,12 @@ var _ = ginkgo.Describe("GlobalManagedClusterSet", func() {
 
 	ginkgo.It("should recreate GlobalManagedClusterSet successfully after deleted", func() {
 		ginkgo.By("delete GlobalManagedClusterSet")
-		err := clusterClient.ClusterV1beta1().ManagedClusterSets().Delete(context.TODO(), setcontroller.GlobalManagedClusterSetName, metav1.DeleteOptions{})
+		err := clusterClient.ClusterV1beta2().ManagedClusterSets().Delete(context.TODO(), setcontroller.GlobalManagedClusterSetName, metav1.DeleteOptions{})
 		gomega.Expect(err).NotTo(gomega.HaveOccurred(), "try to delete GlobalManagedClusterSet error")
 
 		ginkgo.By("check whether GlobalManagedClusterSet is recreated")
 		gomega.Eventually(func() error {
-			mcs, err := clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.TODO(), setcontroller.GlobalManagedClusterSetName, metav1.GetOptions{})
+			mcs, err := clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.TODO(), setcontroller.GlobalManagedClusterSetName, metav1.GetOptions{})
 			if err != nil {
 				return err
 			}
diff --git a/test/integration/managedclusterset_test.go b/test/integration/managedclusterset_test.go
index 9157aab66..8c659b14f 100644
--- a/test/integration/managedclusterset_test.go
+++ b/test/integration/managedclusterset_test.go
@@ -10,7 +10,7 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/rand"
 	clusterv1 "open-cluster-management.io/api/cluster/v1"
-	clusterv1beta1 "open-cluster-management.io/api/cluster/v1beta1"
+	clusterv1beta2 "open-cluster-management.io/api/cluster/v1beta2"
 )
 
 var _ = ginkgo.Describe("ManagedClusterSet", func() {
@@ -19,24 +19,24 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 			suffix := rand.String(6)
 			ginkgo.By("Create a ManagedClusterSet")
 			managedClusterSetName := fmt.Sprintf("cs1-%s", suffix)
-			managedClusterSet := &clusterv1beta1.ManagedClusterSet{
+			managedClusterSet := &clusterv1beta2.ManagedClusterSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name: managedClusterSetName,
 				},
 			}
 
-			_, err := clusterClient.ClusterV1beta1().ManagedClusterSets().Create(context.Background(), managedClusterSet, metav1.CreateOptions{})
+			_, err := clusterClient.ClusterV1beta2().ManagedClusterSets().Create(context.Background(), managedClusterSet, metav1.CreateOptions{})
 			gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 			ginkgo.By("Check if ManagedClusterSet is reconciled")
 			gomega.Eventually(func() bool {
-				managedClusterSet, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
+				managedClusterSet, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
 				if err != nil {
 					return false
 				}
 
 				for _, condition := range managedClusterSet.Status.Conditions {
-					if condition.Type != clusterv1beta1.ManagedClusterSetConditionEmpty {
+					if condition.Type != clusterv1beta2.ManagedClusterSetConditionEmpty {
 						continue
 					}
 					if condition.Status != metav1.ConditionTrue {
@@ -56,7 +56,7 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 				ObjectMeta: metav1.ObjectMeta{
 					Name: managedClusterName,
 					Labels: map[string]string{
-						clusterv1beta1.ClusterSetLabel: managedClusterSetName,
+						clusterv1beta2.ClusterSetLabel: managedClusterSetName,
 					},
 				},
 				Spec: clusterv1.ManagedClusterSpec{
@@ -69,12 +69,12 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 
 			ginkgo.By("Check if ManagedClusterSet is reconciled again")
 			gomega.Eventually(func() bool {
-				managedClusterSet, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
+				managedClusterSet, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
 				if err != nil {
 					return false
 				}
 				for _, condition := range managedClusterSet.Status.Conditions {
-					if condition.Type != clusterv1beta1.ManagedClusterSetConditionEmpty {
+					if condition.Type != clusterv1beta2.ManagedClusterSetConditionEmpty {
 						continue
 					}
 					if condition.Status != metav1.ConditionFalse {
@@ -90,12 +90,12 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 
 			ginkgo.By("Move the cluster to another ManagedClusterSet and check if the original one is empty again")
 			// create another clusterset
-			managedClusterSet = &clusterv1beta1.ManagedClusterSet{
+			managedClusterSet = &clusterv1beta2.ManagedClusterSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name: fmt.Sprintf("cs2-%s", suffix),
 				},
 			}
-			_, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Create(context.Background(), managedClusterSet, metav1.CreateOptions{})
+			_, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Create(context.Background(), managedClusterSet, metav1.CreateOptions{})
 			gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 			gomega.Eventually(func() error {
@@ -105,7 +105,7 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 					return err
 				}
 				managedCluster.Labels = map[string]string{
-					clusterv1beta1.ClusterSetLabel: managedClusterSet.Name,
+					clusterv1beta2.ClusterSetLabel: managedClusterSet.Name,
 				}
 				_, err := clusterClient.ClusterV1().ManagedClusters().Update(context.Background(), managedCluster, metav1.UpdateOptions{})
 				return err
@@ -113,12 +113,12 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 
 			// check if the new clusterset synced
 			gomega.Eventually(func() bool {
-				managedClusterSet, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.Background(), managedClusterSet.Name, metav1.GetOptions{})
+				managedClusterSet, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.Background(), managedClusterSet.Name, metav1.GetOptions{})
 				if err != nil {
 					return false
 				}
 				for _, condition := range managedClusterSet.Status.Conditions {
-					if condition.Type != clusterv1beta1.ManagedClusterSetConditionEmpty {
+					if condition.Type != clusterv1beta2.ManagedClusterSetConditionEmpty {
 						continue
 					}
 					if condition.Status != metav1.ConditionFalse {
@@ -134,12 +134,12 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 
 			// check if the original clusterset synced
 			gomega.Eventually(func() error {
-				managedClusterSet, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
+				managedClusterSet, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
 				if err != nil {
 					return err
 				}
 
-				cond := meta.FindStatusCondition(managedClusterSet.Status.Conditions, clusterv1beta1.ManagedClusterSetConditionEmpty)
+				cond := meta.FindStatusCondition(managedClusterSet.Status.Conditions, clusterv1beta2.ManagedClusterSetConditionEmpty)
 				if cond == nil {
 					return fmt.Errorf("clusterset empty condition is not found")
 				}
@@ -160,29 +160,29 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 		suffix := rand.String(6)
 		ginkgo.By("Create a ManagedClusterSet")
 		managedClusterSetName := fmt.Sprintf("cs1-%s", suffix)
-		managedClusterSet := &clusterv1beta1.ManagedClusterSet{
+		managedClusterSet := &clusterv1beta2.ManagedClusterSet{
 			ObjectMeta: metav1.ObjectMeta{
 				Name: managedClusterSetName,
 			},
-			Spec: clusterv1beta1.ManagedClusterSetSpec{
-				ClusterSelector: clusterv1beta1.ManagedClusterSelector{
-					SelectorType: clusterv1beta1.LegacyClusterSetLabel,
+			Spec: clusterv1beta2.ManagedClusterSetSpec{
+				ClusterSelector: clusterv1beta2.ManagedClusterSelector{
+					SelectorType: clusterv1beta2.ExclusiveClusterSetLabel,
 				},
 			},
 		}
 
-		_, err := clusterClient.ClusterV1beta1().ManagedClusterSets().Create(context.Background(), managedClusterSet, metav1.CreateOptions{})
+		_, err := clusterClient.ClusterV1beta2().ManagedClusterSets().Create(context.Background(), managedClusterSet, metav1.CreateOptions{})
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 		ginkgo.By("Check if ManagedClusterSet is reconciled")
 		gomega.Eventually(func() bool {
-			managedClusterSet, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
+			managedClusterSet, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
 			if err != nil {
 				return false
 			}
 
 			for _, condition := range managedClusterSet.Status.Conditions {
-				if condition.Type != clusterv1beta1.ManagedClusterSetConditionEmpty {
+				if condition.Type != clusterv1beta2.ManagedClusterSetConditionEmpty {
 					continue
 				}
 				if condition.Status != metav1.ConditionTrue {
@@ -202,7 +202,7 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 			ObjectMeta: metav1.ObjectMeta{
 				Name: managedClusterName,
 				Labels: map[string]string{
-					clusterv1beta1.ClusterSetLabel: managedClusterSetName,
+					clusterv1beta2.ClusterSetLabel: managedClusterSetName,
 				},
 			},
 			Spec: clusterv1.ManagedClusterSpec{
@@ -215,12 +215,12 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 
 		ginkgo.By("Check if ManagedClusterSet is reconciled again")
 		gomega.Eventually(func() bool {
-			managedClusterSet, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
+			managedClusterSet, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
 			if err != nil {
 				return false
 			}
 			for _, condition := range managedClusterSet.Status.Conditions {
-				if condition.Type != clusterv1beta1.ManagedClusterSetConditionEmpty {
+				if condition.Type != clusterv1beta2.ManagedClusterSetConditionEmpty {
 					continue
 				}
 				if condition.Status != metav1.ConditionFalse {
@@ -236,12 +236,12 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 
 		ginkgo.By("Move the cluster to another ManagedClusterSet and check if the original one is empty again")
 		// create another clusterset
-		managedClusterSet = &clusterv1beta1.ManagedClusterSet{
+		managedClusterSet = &clusterv1beta2.ManagedClusterSet{
 			ObjectMeta: metav1.ObjectMeta{
 				Name: fmt.Sprintf("cs2-%s", suffix),
 			},
 		}
-		_, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Create(context.Background(), managedClusterSet, metav1.CreateOptions{})
+		_, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Create(context.Background(), managedClusterSet, metav1.CreateOptions{})
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 		gomega.Eventually(func() error {
@@ -251,7 +251,7 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 				return err
 			}
 			managedCluster.Labels = map[string]string{
-				clusterv1beta1.ClusterSetLabel: managedClusterSet.Name,
+				clusterv1beta2.ClusterSetLabel: managedClusterSet.Name,
 			}
 			_, err := clusterClient.ClusterV1().ManagedClusters().Update(context.Background(), managedCluster, metav1.UpdateOptions{})
 			return err
@@ -259,12 +259,12 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 
 		// check if the new clusterset synced
 		gomega.Eventually(func() bool {
-			managedClusterSet, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.Background(), managedClusterSet.Name, metav1.GetOptions{})
+			managedClusterSet, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.Background(), managedClusterSet.Name, metav1.GetOptions{})
 			if err != nil {
 				return false
 			}
 			for _, condition := range managedClusterSet.Status.Conditions {
-				if condition.Type != clusterv1beta1.ManagedClusterSetConditionEmpty {
+				if condition.Type != clusterv1beta2.ManagedClusterSetConditionEmpty {
 					continue
 				}
 				if condition.Status != metav1.ConditionFalse {
@@ -280,12 +280,12 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 
 		// check if the original clusterset synced
 		gomega.Eventually(func() error {
-			managedClusterSet, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
+			managedClusterSet, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
 			if err != nil {
 				return err
 			}
 
-			cond := meta.FindStatusCondition(managedClusterSet.Status.Conditions, clusterv1beta1.ManagedClusterSetConditionEmpty)
+			cond := meta.FindStatusCondition(managedClusterSet.Status.Conditions, clusterv1beta2.ManagedClusterSetConditionEmpty)
 			if cond == nil {
 				return fmt.Errorf("clusterset empty condition is not found")
 			}
@@ -305,13 +305,13 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 		suffix := rand.String(6)
 		ginkgo.By("Create a ManagedClusterSet")
 		managedClusterSetName := fmt.Sprintf("cs1-%s", suffix)
-		managedClusterSet := &clusterv1beta1.ManagedClusterSet{
+		managedClusterSet := &clusterv1beta2.ManagedClusterSet{
 			ObjectMeta: metav1.ObjectMeta{
 				Name: managedClusterSetName,
 			},
-			Spec: clusterv1beta1.ManagedClusterSetSpec{
-				ClusterSelector: clusterv1beta1.ManagedClusterSelector{
-					SelectorType: clusterv1beta1.LabelSelector,
+			Spec: clusterv1beta2.ManagedClusterSetSpec{
+				ClusterSelector: clusterv1beta2.ManagedClusterSelector{
+					SelectorType: clusterv1beta2.LabelSelector,
 					LabelSelector: &metav1.LabelSelector{
 						MatchLabels: map[string]string{
 							"vendor": "openShift",
@@ -321,18 +321,18 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 			},
 		}
 
-		_, err := clusterClient.ClusterV1beta1().ManagedClusterSets().Create(context.Background(), managedClusterSet, metav1.CreateOptions{})
+		_, err := clusterClient.ClusterV1beta2().ManagedClusterSets().Create(context.Background(), managedClusterSet, metav1.CreateOptions{})
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 		ginkgo.By("Check if ManagedClusterSet is reconciled")
 		gomega.Eventually(func() bool {
-			managedClusterSet, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
+			managedClusterSet, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
 			if err != nil {
 				return false
 			}
 
 			for _, condition := range managedClusterSet.Status.Conditions {
-				if condition.Type != clusterv1beta1.ManagedClusterSetConditionEmpty {
+				if condition.Type != clusterv1beta2.ManagedClusterSetConditionEmpty {
 					continue
 				}
 				if condition.Status != metav1.ConditionTrue {
@@ -365,12 +365,12 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 
 		ginkgo.By("Check if ManagedClusterSet is reconciled again")
 		gomega.Eventually(func() bool {
-			managedClusterSet, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
+			managedClusterSet, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
 			if err != nil {
 				return false
 			}
 			for _, condition := range managedClusterSet.Status.Conditions {
-				if condition.Type != clusterv1beta1.ManagedClusterSetConditionEmpty {
+				if condition.Type != clusterv1beta2.ManagedClusterSetConditionEmpty {
 					continue
 				}
 				if condition.Status != metav1.ConditionFalse {
@@ -386,13 +386,13 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 
 		ginkgo.By("Create a new ManagedClusterSet")
 		newManagedClusterSetName := fmt.Sprintf("cs2-%s", suffix)
-		newManagedClusterSet := &clusterv1beta1.ManagedClusterSet{
+		newManagedClusterSet := &clusterv1beta2.ManagedClusterSet{
 			ObjectMeta: metav1.ObjectMeta{
 				Name: newManagedClusterSetName,
 			},
-			Spec: clusterv1beta1.ManagedClusterSetSpec{
-				ClusterSelector: clusterv1beta1.ManagedClusterSelector{
-					SelectorType: clusterv1beta1.LabelSelector,
+			Spec: clusterv1beta2.ManagedClusterSetSpec{
+				ClusterSelector: clusterv1beta2.ManagedClusterSelector{
+					SelectorType: clusterv1beta2.LabelSelector,
 					LabelSelector: &metav1.LabelSelector{
 						MatchLabels: map[string]string{
 							"region": "apac",
@@ -402,7 +402,7 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 			},
 		}
 
-		_, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Create(context.Background(), newManagedClusterSet, metav1.CreateOptions{})
+		_, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Create(context.Background(), newManagedClusterSet, metav1.CreateOptions{})
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 		gomega.Eventually(func() error {
@@ -420,12 +420,12 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 
 		// check if the new clusterset synced
 		gomega.Eventually(func() bool {
-			newManagedClusterSet, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.Background(), newManagedClusterSet.Name, metav1.GetOptions{})
+			newManagedClusterSet, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.Background(), newManagedClusterSet.Name, metav1.GetOptions{})
 			if err != nil {
 				return false
 			}
 			for _, condition := range managedClusterSet.Status.Conditions {
-				if condition.Type != clusterv1beta1.ManagedClusterSetConditionEmpty {
+				if condition.Type != clusterv1beta2.ManagedClusterSetConditionEmpty {
 					continue
 				}
 				if condition.Status != metav1.ConditionFalse {
@@ -441,12 +441,12 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 
 		// check if the original clusterset synced
 		gomega.Eventually(func() error {
-			managedClusterSet, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
+			managedClusterSet, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
 			if err != nil {
 				return err
 			}
 
-			cond := meta.FindStatusCondition(managedClusterSet.Status.Conditions, clusterv1beta1.ManagedClusterSetConditionEmpty)
+			cond := meta.FindStatusCondition(managedClusterSet.Status.Conditions, clusterv1beta2.ManagedClusterSetConditionEmpty)
 			if cond == nil {
 				return fmt.Errorf("clusterset empty condition is not found")
 			}
@@ -484,29 +484,29 @@ var _ = ginkgo.Describe("ManagedClusterSet", func() {
 
 		ginkgo.By("Create a ManagedClusterSet")
 		managedClusterSetName := fmt.Sprintf("cs1-%s", suffix)
-		managedClusterSet := &clusterv1beta1.ManagedClusterSet{
+		managedClusterSet := &clusterv1beta2.ManagedClusterSet{
 			ObjectMeta: metav1.ObjectMeta{
 				Name: managedClusterSetName,
 			},
-			Spec: clusterv1beta1.ManagedClusterSetSpec{
-				ClusterSelector: clusterv1beta1.ManagedClusterSelector{
-					SelectorType:  clusterv1beta1.LabelSelector,
+			Spec: clusterv1beta2.ManagedClusterSetSpec{
+				ClusterSelector: clusterv1beta2.ManagedClusterSelector{
+					SelectorType:  clusterv1beta2.LabelSelector,
 					LabelSelector: &metav1.LabelSelector{},
 				},
 			},
 		}
 
-		_, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Create(context.Background(), managedClusterSet, metav1.CreateOptions{})
+		_, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Create(context.Background(), managedClusterSet, metav1.CreateOptions{})
 		gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 		ginkgo.By("Check if ManagedClusterSet is reconciled")
 		gomega.Eventually(func() bool {
-			managedClusterSet, err = clusterClient.ClusterV1beta1().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
+			managedClusterSet, err = clusterClient.ClusterV1beta2().ManagedClusterSets().Get(context.Background(), managedClusterSetName, metav1.GetOptions{})
 			if err != nil {
 				return false
 			}
 			for _, condition := range managedClusterSet.Status.Conditions {
-				if condition.Type != clusterv1beta1.ManagedClusterSetConditionEmpty {
+				if condition.Type != clusterv1beta2.ManagedClusterSetConditionEmpty {
 					continue
 				}
 				if condition.Status != metav1.ConditionFalse {