Repository: vmware-tanzu/tanzu-framework (language: go)

Issue:
Add `core-management-plugins-package` as part of TKG meta package
**Bug description**

When creating management-cluster using `package-based-lcm` feature flag enabled, context-scoped CLIPlugin resources are not getting deployed on the management-cluster.

So, when using official building, `tanzu plugin sync` might not be able to find context-scoped plugins. 

**Affected product area (please put an X in all that apply)**

- [ ] APIs
- [ ] Addons
- [x] CLI
- [ ] Docs
- [ ] IAM
- [ ] Installation
- [x] Plugin
- [ ] Security
- [ ] Test and Release
- [ ] User Experience

**Expected behavior**
CLIPlugin should be available 


**Steps to reproduce the bug**

**Version** (include the SHA if the version is not obvious)

**Environment where the bug was observed (cloud, OS, etc)**

**Relevant Debug Output (Logs, manifests, etc)**



Discussion / hints:

Fix patch:
diff --git a/docs/cli/tkgctl/management-cluster-using-clusterclass.md b/docs/cli/tkgctl/management-cluster-using-clusterclass.md
index 21d0515b4e..69c2e54c0f 100644
--- a/docs/cli/tkgctl/management-cluster-using-clusterclass.md
+++ b/docs/cli/tkgctl/management-cluster-using-clusterclass.md
@@ -6,7 +6,7 @@ Below is the sequence of management-cluster creation using clusterclass.
 1. Deploy `kapp-controller` on bootstrap cluster
 1. Deploy `providers` on bootstrap cluster
 1. Deploy `TKG meta package` to bootstrap cluster
-    * Hack: Using `_ADDITIONAL_MANAGEMENT_COMPONENT_CONFIGURATION_FILE` to deploy additional components that are not getting deployed as part of `TKG meta package` at the moment. This includes TKR package related resource. This is only for testing purpose and should be removed once TKG package related changes are in.
+    1. As part of this package installation we will be creating configmap with label `run.tanzu.vmware.com/additional-compatible-tkrs` to make default TKR compatible.
 1. Wait for packages to get deployed on management-cluster
 1. Apply `CCluster.yaml` to create management-cluster using default clusterclass
 1. Wait for CAPx controllers to reconcile the CCluster and deploy a management-cluster on specified infra
diff --git a/packages/core-management-plugins/bundle/config/cliplugin-crd.yaml b/packages/core-management-plugins/bundle/config/cliplugin-crd.yaml
index 4ad9a80b9a..f19c8f0059 100644
--- a/packages/core-management-plugins/bundle/config/cliplugin-crd.yaml
+++ b/packages/core-management-plugins/bundle/config/cliplugin-crd.yaml
@@ -1,3 +1,8 @@
+#@ load("@ytt:data", "data")
+#@ load("@ytt:yaml", "yaml")
+
+#@ if data.values.deployCLIPluginCRD:
+
 ---
 apiVersion: apiextensions.k8s.io/v1
 kind: CustomResourceDefinition
@@ -102,3 +107,5 @@ spec:
           type: object
       served: true
       storage: true
+
+#@ end
diff --git a/packages/core-management-plugins/bundle/config/values.yaml b/packages/core-management-plugins/bundle/config/values.yaml
new file mode 100644
index 0000000000..b313602935
--- /dev/null
+++ b/packages/core-management-plugins/bundle/config/values.yaml
@@ -0,0 +1,5 @@
+#@data/values
+#@overlay/match-child-defaults missing_ok=True
+
+---
+deployCLIPluginCRD: true
diff --git a/packages/tkg-clusterclass-aws/bundle/config/upstream/base.yaml b/packages/tkg-clusterclass-aws/bundle/config/upstream/base.yaml
index e8ef0b5334..fa5ead9a55 100644
--- a/packages/tkg-clusterclass-aws/bundle/config/upstream/base.yaml
+++ b/packages/tkg-clusterclass-aws/bundle/config/upstream/base.yaml
@@ -209,7 +209,6 @@ spec:
         properties:
           host:
             type: string
-            format: uri
           tlsCertificateValidation:
             type: boolean
             default: true
@@ -1028,7 +1027,9 @@ spec:
     spec:
       kubeadmConfigSpec:
         files: []
-        preKubeadmCommands: []
+        preKubeadmCommands:
+        #! Ensure a non-empty preKubeadmCommands array is present to facilitate patching
+        - echo "running preKubeadmCommands…"
         useExperimentalRetryJoin: true
         clusterConfiguration:
           apiServer:
diff --git a/packages/tkg-clusterclass-azure/bundle/config/upstream/base.yaml b/packages/tkg-clusterclass-azure/bundle/config/upstream/base.yaml
index 3d78b64d0e..938e814f2b 100644
--- a/packages/tkg-clusterclass-azure/bundle/config/upstream/base.yaml
+++ b/packages/tkg-clusterclass-azure/bundle/config/upstream/base.yaml
@@ -437,11 +437,26 @@ spec:
             managedDisk:
               storageAccountType: {{ .controlPlane.osDisk.storageAccountType }}
       - op: replace
-        path: /spec/template/spec/image/marketplace
+        path: /spec/template/spec/image
         valueFrom:
           template: |
-            {{ range $k, $v := (index .TKR_DATA .builtin.controlPlane.version).osImageRef }} {{- $k -}} : {{ $v }}
-            {{ end }}
+            {{- $osImageRef := (index .TKR_DATA .builtin.controlPlane.version).osImageRef -}}
+            {{- if index $osImageRef "gallery" }}
+            sharedGallery:
+              resourceGroup: {{ index $osImageRef "resourceGroup" }}
+              name: {{ index $osImageRef "name" }}
+              subscriptionID: {{ index $osImageRef "subscriptionID" }}
+              gallery: {{ index $osImageRef "gallery" }}
+              version: {{ index $osImageRef "version" }}
+            {{- end }}
+            {{- if index $osImageRef "sku" }}
+            marketplace:
+              sku: {{ index $osImageRef "sku" }}
+              publisher: {{ index $osImageRef "publisher" }}
+              offer: {{ index $osImageRef "offer" }}
+              version: {{ index $osImageRef "version" }}
+              thirdPartyImage: {{ index $osImageRef "thirdPartyImage" }}
+            {{- end -}}
   - name: KCPT_ControlPlane_Main
     definitions:
     - selector:
@@ -539,11 +554,26 @@ spec:
             managedDisk:
               storageAccountType: {{ .worker.osDisk.storageAccountType }}
       - op: replace
-        path: /spec/template/spec/image/marketplace
+        path: /spec/template/spec/image
         valueFrom:
           template: |
-            {{ range $k, $v := (index .TKR_DATA .builtin.machineDeployment.version).osImageRef }} {{- $k -}} : {{ $v }}
-            {{ end }}
+            {{- $osImageRef := (index .TKR_DATA .builtin.machineDeployment.version).osImageRef -}}
+            {{- if index $osImageRef "gallery" }}
+            sharedGallery:
+              resourceGroup: {{ index $osImageRef "resourceGroup" }}
+              name: {{ index $osImageRef "name" }}
+              subscriptionID: {{ index $osImageRef "subscriptionID" }}
+              gallery: {{ index $osImageRef "gallery" }}
+              version: {{ index $osImageRef "version" }}
+            {{- end }}
+            {{- if index $osImageRef "sku" }}
+            marketplace:
+              sku: {{ index $osImageRef "sku" }}
+              publisher: {{ index $osImageRef "publisher" }}
+              offer: {{ index $osImageRef "offer" }}
+              version: {{ index $osImageRef "version" }}
+              thirdPartyImage: {{ index $osImageRef "thirdPartyImage" }}
+            {{- end -}}
   - name: KCT_Worker_Main
     definitions:
     - selector:
@@ -1295,7 +1325,9 @@ spec:
           - /var/lib/etcddisk
         useExperimentalRetryJoin: true
         postKubeadmCommands: []
-        preKubeadmCommands: []
+        preKubeadmCommands:
+        #! Ensure a non-empty preKubeadmCommands array is present to facilitate patching
+        - echo "running preKubeadmCommands…"
       machineTemplate:
         infrastructureRef:
           apiVersion: infrastructure.cluster.x-k8s.io/v1beta1
diff --git a/packages/tkg/bundle/config/packageinstalls/core-management-plugins-pi.yaml b/packages/tkg/bundle/config/packageinstalls/core-management-plugins-pi.yaml
new file mode 100644
index 0000000000..e71f35e375
--- /dev/null
+++ b/packages/tkg/bundle/config/packageinstalls/core-management-plugins-pi.yaml
@@ -0,0 +1,40 @@
+#@ load("@ytt:data", "data")
+#@ load("@ytt:yaml", "yaml")
+
+---
+apiVersion: packaging.carvel.dev/v1alpha1
+kind: PackageInstall
+metadata:
+  name: core-management-plugins
+  namespace: #@ data.values.coreManagementPluginsPackage.namespaceForPackageInstallation
+  annotations:
+    kapp.k14s.io/change-rule.0: "upsert after upserting framework-packageinstall/tanzu-framework"
+    kapp.k14s.io/change-rule.1: "upsert after upserting core-management-plugins-packageinstall/serviceaccount"
+    kapp.k14s.io/change-rule.2: "delete before deleting core-management-plugins-packageinstall/serviceaccount"
+
+  labels:
+    tkg.tanzu.vmware.com/package-type: "management"
+spec:
+  serviceAccountName: core-management-plugins-package-sa
+  packageRef:
+    refName: core-management-plugins.tanzu.vmware.com
+    versionSelection:
+      prereleases: {}
+      #@ if data.values.coreManagementPluginsPackage.versionConstraints:
+      constraints: #@ data.values.coreManagementPluginsPackage.versionConstraints
+      #@ end
+  values:
+    - secretRef:
+        name: core-management-plugins-values
+---
+apiVersion: v1
+kind: Secret
+metadata:
+  name: core-management-plugins-values
+  namespace: #@ data.values.coreManagementPluginsPackage.namespaceForPackageInstallation
+  annotations:
+    kapp.k14s.io/change-rule.0: "upsert after upserting core-management-plugins-packageinstall/serviceaccount"
+    kapp.k14s.io/change-rule.1: "delete before deleting core-management-plugins-packageinstall/serviceaccount"
+type: Opaque
+stringData:
+  values.yaml: #@ yaml.encode(data.values.coreManagementPluginsPackage.coreManagementPluginsPackageValues)
diff --git a/packages/tkg/bundle/config/packageinstalls/core-management-plugins-service-account.yaml b/packages/tkg/bundle/config/packageinstalls/core-management-plugins-service-account.yaml
new file mode 100644
index 0000000000..7b3581fe4e
--- /dev/null
+++ b/packages/tkg/bundle/config/packageinstalls/core-management-plugins-service-account.yaml
@@ -0,0 +1,39 @@
+#@ load("@ytt:data", "data")
+
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: core-management-plugins-package-sa
+  namespace: #@ data.values.coreManagementPluginsPackage.namespaceForPackageInstallation
+  annotations:
+    kapp.k14s.io/change-group: "core-management-plugins-packageinstall/serviceaccount-0"
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: core-management-plugins-package-role
+  annotations:
+    kapp.k14s.io/change-group: "core-management-plugins-packageinstall/serviceaccount-0"
+rules:
+  #  RBAC rules to create PackageInstall CR and service accounts
+  - apiGroups: ["*"]
+    resources: ["*"]
+    verbs: ["*"]
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: core-management-plugins-package-cluster-rolebinding
+  annotations:
+    kapp.k14s.io/change-group: "core-management-plugins-packageinstall/serviceaccount"
+    kapp.k14s.io/change-rule.0: "upsert after upserting core-management-plugins-packageinstall/serviceaccount-0"
+    kapp.k14s.io/change-rule.1: "delete before deleting core-management-plugins-packageinstall/serviceaccount-0"
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: core-management-plugins-package-role
+subjects:
+  - kind: ServiceAccount
+    name: core-management-plugins-package-sa
+    namespace: #@ data.values.coreManagementPluginsPackage.namespaceForPackageInstallation
diff --git a/packages/tkg/bundle/config/values.yaml b/packages/tkg/bundle/config/values.yaml
index 368a0a1b20..ce128c1101 100644
--- a/packages/tkg/bundle/config/values.yaml
+++ b/packages/tkg/bundle/config/values.yaml
@@ -71,6 +71,7 @@ tkrSourceControllerPackage:
     bomImagePath:
     bomMetadataImagePath:
     tkrRepoImagePath:
+    defaultCompatibleTKR:
     skipVerifyRegistryCert: false
     initialDiscoverFrequency: 60
     continuousDiscoverFrequency: 600
@@ -81,3 +82,9 @@ tkrSourceControllerPackage:
       httpProxy:
       httpsProxy:
       noProxy:
+
+coreManagementPluginsPackage:
+  namespaceForPackageInstallation: tkg-system
+  versionConstraints:
+  coreManagementPluginsPackageValues:
+    deployCLIPluginCRD: false
diff --git a/packages/tkr-source-controller/bundle/config/upstream/default-compatible-tkr.yaml b/packages/tkr-source-controller/bundle/config/upstream/default-compatible-tkr.yaml
new file mode 100644
index 0000000000..1e197860f2
--- /dev/null
+++ b/packages/tkr-source-controller/bundle/config/upstream/default-compatible-tkr.yaml
@@ -0,0 +1,17 @@
+#@ load("@ytt:data", "data")
+#@ load("@ytt:yaml", "yaml")
+
+#@ def getCompatibleTKRs():
+- #@ data.values.defaultCompatibleTKR
+#@ end
+
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  labels:
+    run.tanzu.vmware.com/additional-compatible-tkrs: ""
+  name: tkg-compatibility-versions
+  namespace: #@ data.values.namespace
+data:
+  tkrVersions: #@ yaml.encode(getCompatibleTKRs())
diff --git a/packages/tkr-source-controller/bundle/config/values.yaml b/packages/tkr-source-controller/bundle/config/values.yaml
index 96c00d5bdf..6a5945ad03 100644
--- a/packages/tkr-source-controller/bundle/config/values.yaml
+++ b/packages/tkr-source-controller/bundle/config/values.yaml
@@ -5,6 +5,7 @@ namespace: tkg-system
 bomImagePath:
 bomMetadataImagePath:
 tkrRepoImagePath:
+defaultCompatibleTKR:
 skipVerifyRegistryCert: false
 initialDiscoverFrequency: 60
 continuousDiscoverFrequency: 600
diff --git a/pkg/v1/providers/infrastructure-aws/v1.2.0/cconly/base.yaml b/pkg/v1/providers/infrastructure-aws/v1.2.0/cconly/base.yaml
index e8ef0b5334..fa5ead9a55 100644
--- a/pkg/v1/providers/infrastructure-aws/v1.2.0/cconly/base.yaml
+++ b/pkg/v1/providers/infrastructure-aws/v1.2.0/cconly/base.yaml
@@ -209,7 +209,6 @@ spec:
         properties:
           host:
             type: string
-            format: uri
           tlsCertificateValidation:
             type: boolean
             default: true
@@ -1028,7 +1027,9 @@ spec:
     spec:
       kubeadmConfigSpec:
         files: []
-        preKubeadmCommands: []
+        preKubeadmCommands:
+        #! Ensure a non-empty preKubeadmCommands array is present to facilitate patching
+        - echo "running preKubeadmCommands…"
         useExperimentalRetryJoin: true
         clusterConfiguration:
           apiServer:
diff --git a/pkg/v1/providers/infrastructure-azure/v1.2.1/cconly/base.yaml b/pkg/v1/providers/infrastructure-azure/v1.2.1/cconly/base.yaml
index 3d78b64d0e..938e814f2b 100644
--- a/pkg/v1/providers/infrastructure-azure/v1.2.1/cconly/base.yaml
+++ b/pkg/v1/providers/infrastructure-azure/v1.2.1/cconly/base.yaml
@@ -437,11 +437,26 @@ spec:
             managedDisk:
               storageAccountType: {{ .controlPlane.osDisk.storageAccountType }}
       - op: replace
-        path: /spec/template/spec/image/marketplace
+        path: /spec/template/spec/image
         valueFrom:
           template: |
-            {{ range $k, $v := (index .TKR_DATA .builtin.controlPlane.version).osImageRef }} {{- $k -}} : {{ $v }}
-            {{ end }}
+            {{- $osImageRef := (index .TKR_DATA .builtin.controlPlane.version).osImageRef -}}
+            {{- if index $osImageRef "gallery" }}
+            sharedGallery:
+              resourceGroup: {{ index $osImageRef "resourceGroup" }}
+              name: {{ index $osImageRef "name" }}
+              subscriptionID: {{ index $osImageRef "subscriptionID" }}
+              gallery: {{ index $osImageRef "gallery" }}
+              version: {{ index $osImageRef "version" }}
+            {{- end }}
+            {{- if index $osImageRef "sku" }}
+            marketplace:
+              sku: {{ index $osImageRef "sku" }}
+              publisher: {{ index $osImageRef "publisher" }}
+              offer: {{ index $osImageRef "offer" }}
+              version: {{ index $osImageRef "version" }}
+              thirdPartyImage: {{ index $osImageRef "thirdPartyImage" }}
+            {{- end -}}
   - name: KCPT_ControlPlane_Main
     definitions:
     - selector:
@@ -539,11 +554,26 @@ spec:
             managedDisk:
               storageAccountType: {{ .worker.osDisk.storageAccountType }}
       - op: replace
-        path: /spec/template/spec/image/marketplace
+        path: /spec/template/spec/image
         valueFrom:
           template: |
-            {{ range $k, $v := (index .TKR_DATA .builtin.machineDeployment.version).osImageRef }} {{- $k -}} : {{ $v }}
-            {{ end }}
+            {{- $osImageRef := (index .TKR_DATA .builtin.machineDeployment.version).osImageRef -}}
+            {{- if index $osImageRef "gallery" }}
+            sharedGallery:
+              resourceGroup: {{ index $osImageRef "resourceGroup" }}
+              name: {{ index $osImageRef "name" }}
+              subscriptionID: {{ index $osImageRef "subscriptionID" }}
+              gallery: {{ index $osImageRef "gallery" }}
+              version: {{ index $osImageRef "version" }}
+            {{- end }}
+            {{- if index $osImageRef "sku" }}
+            marketplace:
+              sku: {{ index $osImageRef "sku" }}
+              publisher: {{ index $osImageRef "publisher" }}
+              offer: {{ index $osImageRef "offer" }}
+              version: {{ index $osImageRef "version" }}
+              thirdPartyImage: {{ index $osImageRef "thirdPartyImage" }}
+            {{- end -}}
   - name: KCT_Worker_Main
     definitions:
     - selector:
@@ -1295,7 +1325,9 @@ spec:
           - /var/lib/etcddisk
         useExperimentalRetryJoin: true
         postKubeadmCommands: []
-        preKubeadmCommands: []
+        preKubeadmCommands:
+        #! Ensure a non-empty preKubeadmCommands array is present to facilitate patching
+        - echo "running preKubeadmCommands…"
       machineTemplate:
         infrastructureRef:
           apiVersion: infrastructure.cluster.x-k8s.io/v1beta1
diff --git a/pkg/v1/tkg/client/cluster.go b/pkg/v1/tkg/client/cluster.go
index fdfb16de44..3f890f01ca 100644
--- a/pkg/v1/tkg/client/cluster.go
+++ b/pkg/v1/tkg/client/cluster.go
@@ -104,9 +104,11 @@ func (c *TkgClient) CreateCluster(options *CreateClusterOptions, waitForCluster
 		return false, errors.Wrap(err, "error determining Tanzu Kubernetes Cluster service for vSphere management cluster ")
 	}
 	if isPacific {
-		err := c.ValidatePacificVersionWithCLI(regionalClusterClient)
-		if err != nil {
-			return false, err
+		if !options.IsInputFileClusterClassBased {
+			err := c.ValidatePacificVersionWithCLI(regionalClusterClient)
+			if err != nil {
+				return false, err
+			}
 		}
 		return true, c.createPacificCluster(options, waitForCluster)
 	}
@@ -194,7 +196,7 @@ func (c *TkgClient) CreateCluster(options *CreateClusterOptions, waitForCluster
 	if !waitForCluster {
 		return false, nil
 	}
-	return true, c.waitForClusterCreation(regionalClusterClient, options)
+	return true, c.waitForClusterCreation(regionalClusterClient, options, isPacific)
 }
 
 // getClusterConfigurationBytes returns cluster configuration by taking into consideration of legacy vs clusterclass based cluster creation
@@ -225,7 +227,7 @@ func getContentFromInputFile(fileName string) ([]byte, error) {
 	return content, nil
 }
 
-func (c *TkgClient) waitForClusterCreation(regionalClusterClient clusterclient.Client, options *CreateClusterOptions) error {
+func (c *TkgClient) waitForClusterCreation(regionalClusterClient clusterclient.Client, options *CreateClusterOptions, isTKGSCluster bool) error {
 	log.Info("Waiting for cluster to be initialized...")
 	kubeConfigBytes, err := c.WaitForClusterInitializedAndGetKubeConfig(regionalClusterClient, options.ClusterName, options.TargetNamespace)
 	if err != nil {
@@ -257,22 +259,22 @@ func (c *TkgClient) waitForClusterCreation(regionalClusterClient clusterclient.C
 		return errors.Wrap(err, "unable to create workload cluster client")
 	}
 
-	log.Info("Waiting for addons installation...")
-	if err := c.WaitForAddons(waitForAddonsOptions{
-		regionalClusterClient: regionalClusterClient,
-		workloadClusterClient: workloadClusterClient,
-		clusterName:           options.ClusterName,
-		namespace:             options.TargetNamespace,
-		waitForCNI:            true,
-	}); err != nil {
-		return errors.Wrap(err, "error waiting for addons to get installed")
-	}
-
-	log.Info("Waiting for packages to be up and running...")
-	if err := c.WaitForPackages(regionalClusterClient, workloadClusterClient, options.ClusterName, options.TargetNamespace, false); err != nil {
-		log.Warningf("Warning: Cluster is created successfully, but some packages are failing. %v", err)
+	if !isTKGSCluster {
+		log.Info("Waiting for addons installation...")
+		if err := c.WaitForAddons(waitForAddonsOptions{
+			regionalClusterClient: regionalClusterClient,
+			workloadClusterClient: workloadClusterClient,
+			clusterName:           options.ClusterName,
+			namespace:             options.TargetNamespace,
+			waitForCNI:            true,
+		}); err != nil {
+			return errors.Wrap(err, "error waiting for addons to get installed")
+		}
+		log.Info("Waiting for packages to be up and running...")
+		if err := c.WaitForPackages(regionalClusterClient, workloadClusterClient, options.ClusterName, options.TargetNamespace, false); err != nil {
+			log.Warningf("Warning: Cluster is created successfully, but some packages are failing. %v", err)
+		}
 	}
-
 	return nil
 }
 
@@ -467,8 +469,12 @@ func (c *TkgClient) createPacificCluster(options *CreateClusterOptions, waitForC
 	}
 
 	log.V(3).Infof("Waiting for the Tanzu Kubernetes Cluster service for vSphere workload cluster\n")
-
-	if err := clusterClient.WaitForPacificCluster(clusterName, namespace); err != nil {
+	if options.IsInputFileClusterClassBased {
+		err = c.waitForClusterCreation(clusterClient, options, options.IsInputFileClusterClassBased)
+	} else {
+		err = clusterClient.WaitForPacificCluster(clusterName, namespace)
+	}
+	if err != nil {
 		return errors.Wrap(err, "failed waiting for workload cluster")
 	}
 	return nil
diff --git a/pkg/v1/tkg/client/common.go b/pkg/v1/tkg/client/common.go
index 36df74b9eb..555f7d4aad 100644
--- a/pkg/v1/tkg/client/common.go
+++ b/pkg/v1/tkg/client/common.go
@@ -306,10 +306,10 @@ func (c *TkgClient) isCustomOverlayPresent() (bool, error) {
 }
 
 func (c *TkgClient) ShouldDeployClusterClassBasedCluster(isManagementCluster bool) (bool, error) {
-	var isCustomOverlayDetected bool
+	var isCustomOverlayPresent bool
 	var err error
 
-	if isCustomOverlayDetected, err = c.isCustomOverlayPresent(); err != nil {
+	if isCustomOverlayPresent, err = c.isCustomOverlayPresent(); err != nil {
 		return false, err
 	}
 
@@ -318,14 +318,14 @@ func (c *TkgClient) ShouldDeployClusterClassBasedCluster(isManagementCluster boo
 	// If `package-based-lcm` featureflag is enabled and deploying management cluster
 	// Always use ClusterClass based Cluster deployment
 	if featureFlagPackageBasedLCMEnabled && isManagementCluster {
-		if isCustomOverlayDetected {
+		if isCustomOverlayPresent {
 			log.Warning("Warning: It seems like you have done some customizations to the template overlays. However, CLI might ignore those customizations when creating management-cluster.")
 		}
 		return true, nil
 	}
 
 	deployClusterClassBasedCluster := config.IsFeatureActivated(config.FeatureFlagPackageBasedLCM) &&
-		(config.IsFeatureActivated(config.FeatureFlagForceDeployClusterWithClusterClass) || !isCustomOverlayDetected)
+		(config.IsFeatureActivated(config.FeatureFlagForceDeployClusterWithClusterClass) || !isCustomOverlayPresent)
 
 	return deployClusterClassBasedCluster, nil
 }
diff --git a/pkg/v1/tkg/client/management_components.go b/pkg/v1/tkg/client/management_components.go
index ebaec7ae27..e7060ec71a 100644
--- a/pkg/v1/tkg/client/management_components.go
+++ b/pkg/v1/tkg/client/management_components.go
@@ -54,10 +54,7 @@ func (c *TkgClient) InstallOrUpgradeManagementComponents(kubeconfig, kubecontext
 		return errors.Wrap(err, "unable to get management package repository image")
 	}
 
-	managementPackageVersion, err := c.tkgBomClient.GetManagementPackagesVersion()
-	if err != nil {
-		return errors.Wrap(err, "unable to get version of management packages")
-	}
+	managementPackageVersion := ""
 
 	// Override management package repository image if specified as part of below environment variable
 	// NOTE: this override is only for testing purpose and we don't expect this to be used in production scenario
@@ -69,7 +66,7 @@ func (c *TkgClient) InstallOrUpgradeManagementComponents(kubeconfig, kubecontext
 	// Override the version to use for management packages if specified as part of below environment variable
 	// NOTE: this override is only for testing purpose and we don't expect this to be used in production scenario
 	mpVersion := os.Getenv("_MANAGEMENT_PACKAGE_VERSION")
-	if mprImage != "" {
+	if mpVersion != "" {
 		managementPackageVersion = mpVersion
 	}
 
@@ -105,7 +102,7 @@ func (c *TkgClient) InstallOrUpgradeManagementComponents(kubeconfig, kubecontext
 }
 
 func (c *TkgClient) getTKGPackageConfigValuesFile(managementPackageVersion, kubeconfig, kubecontext string, upgrade bool) (string, error) {
-	var userProviderConfigValues map[string]string
+	var userProviderConfigValues map[string]interface{}
 	var err error
 
 	if upgrade {
@@ -118,7 +115,12 @@ func (c *TkgClient) getTKGPackageConfigValuesFile(managementPackageVersion, kube
 		return "", err
 	}
 
-	valuesFile, err := managementcomponents.GetTKGPackageConfigValuesFileFromUserConfig(managementPackageVersion, userProviderConfigValues)
+	tkgBomConfig, err := c.tkgBomClient.GetDefaultTkgBOMConfiguration()
+	if err != nil {
+		return "", err
+	}
+
+	valuesFile, err := managementcomponents.GetTKGPackageConfigValuesFileFromUserConfig(managementPackageVersion, userProviderConfigValues, tkgBomConfig)
 	if err != nil {
 		return "", err
 	}
@@ -126,7 +128,7 @@ func (c *TkgClient) getTKGPackageConfigValuesFile(managementPackageVersion, kube
 	return valuesFile, nil
 }
 
-func (c *TkgClient) getUserConfigVariableValueMap() (map[string]string, error) {
+func (c *TkgClient) getUserConfigVariableValueMap() (map[string]interface{}, error) {
 	path, err := c.tkgConfigPathsClient.GetConfigDefaultsFilePath()
 	if err != nil {
 		return nil, err
@@ -135,7 +137,7 @@ func (c *TkgClient) getUserConfigVariableValueMap() (map[string]string, error) {
 	return c.GetUserConfigVariableValueMap(path, c.TKGConfigReaderWriter())
 }
 
-func (c *TkgClient) getUserConfigVariableValueMapForUpgrade(kubeconfig, kubecontext string) (map[string]string, error) {
+func (c *TkgClient) getUserConfigVariableValueMapForUpgrade(kubeconfig, kubecontext string) (map[string]interface{}, error) {
 	clusterClient, err := clusterclient.NewClient(kubeconfig, kubecontext, clusterclient.Options{})
 	if err != nil {
 		return nil, errors.Wrap(err, "unable to get cluster client")
@@ -282,7 +284,7 @@ func GetKappControllerConfigValuesFile(userConfigValuesFile, kappControllerValue
 // file to provide a source of keys to filter for the valid user provided values.
 // For example, this function uses config_default.yaml filepath to find relevant config variables
 // and returns the config map of user provided variable among all applicable config variables
-func (c *TkgClient) GetUserConfigVariableValueMap(configDefaultFilePath string, rw tkgconfigreaderwriter.TKGConfigReaderWriter) (map[string]string, error) {
+func (c *TkgClient) GetUserConfigVariableValueMap(configDefaultFilePath string, rw tkgconfigreaderwriter.TKGConfigReaderWriter) (map[string]interface{}, error) {
 	bytes, err := os.ReadFile(configDefaultFilePath)
 	if err != nil {
 		return nil, err
@@ -293,10 +295,10 @@ func (c *TkgClient) GetUserConfigVariableValueMap(configDefaultFilePath string,
 		return nil, err
 	}
 
-	userProvidedConfigValues := map[string]string{}
+	userProvidedConfigValues := map[string]interface{}{}
 	for _, k := range variables {
 		if v, e := rw.Get(k); e == nil {
-			userProvidedConfigValues[k] = v
+			userProvidedConfigValues[k] = utils.Convert(v)
 		}
 	}
 
diff --git a/pkg/v1/tkg/client/validate.go b/pkg/v1/tkg/client/validate.go
index a7d4580479..0876b9914e 100644
--- a/pkg/v1/tkg/client/validate.go
+++ b/pkg/v1/tkg/client/validate.go
@@ -1481,14 +1481,17 @@ func (c *TkgClient) EncodeAWSCredentialsAndGetClient(clusterClient clusterclient
 
 // ValidatePacificVersionWithCLI validate Pacific TKC API version with cli version
 func (c *TkgClient) ValidatePacificVersionWithCLI(regionalClusterClient clusterclient.Client) error {
-	tkcAPIVersion, err := regionalClusterClient.GetPacificTKCAPIVersion()
-	if err != nil {
-		return errors.Wrap(err, "error determining the Tanzu Kubernetes Cluster API version")
-	}
-	if tkcAPIVersion != constants.DefaultPacificClusterAPIVersion {
-		return errors.Errorf("Only %q Tanzu Kubernetes Cluster API version is supported by current version of Tanzu CLI. Please upgrade 'Tanzu Kubernetes Cluster service for vSphere' to latest version if you are using older version",
-			constants.DefaultPacificClusterAPIVersion)
-	}
+	/*
+		TODO: (chandrareddyp) we need revisit below API Version validation, for now we disabled it.
+		tkcAPIVersion, err := regionalClusterClient.GetPacificTKCAPIVersion()
+		if err != nil {
+			return errors.Wrap(err, "error determining the Tanzu Kubernetes Cluster API version")
+		}
+		if tkcAPIVersion != constants.DefaultPacificClusterAPIVersion {
+			return errors.Errorf("Only %q Tanzu Kubernetes Cluster API version is supported by current version of Tanzu CLI. Please upgrade 'Tanzu Kubernetes Cluster service for vSphere' to latest version if you are using older version",
+				constants.DefaultPacificClusterAPIVersion)
+		}
+	*/
 	return nil
 }
 
@@ -1556,10 +1559,14 @@ func (c *TkgClient) getFullTKGNoProxy(providerName string) (string, error) {
 	noProxyMap[constants.LocalHostIP] = true
 
 	if serviceCIDR, _ := c.TKGConfigReaderWriter().Get(constants.ConfigVariableServiceCIDR); serviceCIDR != "" {
-		noProxyMap[serviceCIDR] = true
+		for _, np := range strings.Split(serviceCIDR, ",") {
+			noProxyMap[np] = true
+		}
 	}
 	if clusterCIDR, _ := c.TKGConfigReaderWriter().Get(constants.ConfigVariableClusterCIDR); clusterCIDR != "" {
-		noProxyMap[clusterCIDR] = true
+		for _, np := range strings.Split(clusterCIDR, ",") {
+			noProxyMap[np] = true
+		}
 	}
 	if ipfamily, _ := c.TKGConfigReaderWriter().Get(constants.ConfigVariableIPFamily); ipfamily == constants.IPv6Family {
 		noProxyMap[constants.LocalHostIPv6] = true
@@ -1570,7 +1577,18 @@ func (c *TkgClient) getFullTKGNoProxy(providerName string) (string, error) {
 			noProxyMap[np] = true
 		}
 	}
-	// below provider specific no proxies has not been checked into tkg-cli-providers yet
+	// update provider specific no proxies has not been checked into tkg-cli-providers yet
+	err := c.updateProviderSpecificNoProxy(providerName, noProxyMap)
+
+	noProxyList := []string{}
+	for np := range noProxyMap {
+		noProxyList = append(noProxyList, np)
+	}
+	return strings.Join(noProxyList, ","), err
+}
+
+// updateProviderSpecificNoProxy updates provider specific no proxies to given input map
+func (c *TkgClient) updateProviderSpecificNoProxy(providerName string, noProxyMap map[string]bool) error {
 	switch providerName {
 	case constants.InfrastructureProviderAWS:
 		if vpcCIDR, _ := c.TKGConfigReaderWriter().Get(constants.ConfigVariableAWSVPCCIDR); vpcCIDR != "" {
@@ -1579,7 +1597,9 @@ func (c *TkgClient) getFullTKGNoProxy(providerName string) (string, error) {
 		noProxyMap[constants.LinkLocalAddress] = true
 	case constants.InfrastructureProviderAzure:
 		if vnetCIDR, _ := c.TKGConfigReaderWriter().Get(constants.ConfigVariableAzureVnetCidr); vnetCIDR != "" {
-			noProxyMap[vnetCIDR] = true
+			for _, np := range strings.Split(vnetCIDR, ",") {
+				noProxyMap[np] = true
+			}
 		}
 		noProxyMap[constants.LinkLocalAddress] = true
 		noProxyMap[constants.AzurePublicVIP] = true
@@ -1587,18 +1607,11 @@ func (c *TkgClient) getFullTKGNoProxy(providerName string) (string, error) {
 		var dockerBridgeCidr string
 		var err error
 		if dockerBridgeCidr, err = getDockerBridgeNetworkCidr(); err != nil {
-			return "", err
+			return err
 		}
 		noProxyMap[dockerBridgeCidr] = true
 	}
-
-	noProxyList := []string{}
-
-	for np := range noProxyMap {
-		noProxyList = append(noProxyList, np)
-	}
-
-	return strings.Join(noProxyList, ","), nil
+	return nil
 }
 
 func (c *TkgClient) configureVsphereCredentialsFromCluster(clusterClient clusterclient.Client) error {
diff --git a/pkg/v1/tkg/constants/cluster_internal.go b/pkg/v1/tkg/constants/cluster_internal.go
index 1fbe85ea09..3a2e40f751 100644
--- a/pkg/v1/tkg/constants/cluster_internal.go
+++ b/pkg/v1/tkg/constants/cluster_internal.go
@@ -9,8 +9,8 @@ const (
 	KindCluster                = "Cluster"
 	KindTanzuKubernetesCluster = "TanzuKubernetesCluster"
 	KindClusterClass           = "ClusterClass"
-	CCFeature                  = "clusterclass"
-	TKGSClusterClassNamespace  = "vmware-system-capw"
+	CCFeature                  = "vmware-system-tkg-clusterclass"
+	TKGSClusterClassNamespace  = "vmware-system-tkg"
 	TKGStkcapiNamespace        = "vmware-system-tkg"
 
 	PacificGCMControllerDeployment = "vmware-system-tkg-controller-manager"
@@ -85,6 +85,13 @@ const (
 	InfrastructureProviderDocker  = "docker"
 )
 
+var InfrastructureProviders = map[string]bool{
+	InfrastructureProviderVSphere: true,
+	InfrastructureProviderAWS:     true,
+	InfrastructureProviderAzure:   true,
+	InfrastructureProviderDocker:  true,
+}
+
 // machine template name constants
 const (
 	VSphereMachineTemplate = "VSphereMachineTemplate"
diff --git a/pkg/v1/tkg/constants/clusterclass_mapping.go b/pkg/v1/tkg/constants/clusterclass_mapping.go
new file mode 100644
index 0000000000..54714fcc45
--- /dev/null
+++ b/pkg/v1/tkg/constants/clusterclass_mapping.go
@@ -0,0 +1,301 @@
+// Copyright 2021 VMware, Inc. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package constants
+
+// ClusterAttributesToLegacyVariablesMapCommon has cluster class attributes to legacy variable names, are common for all infra providers.
+var ClusterAttributesToLegacyVariablesMapCommon = map[string]string{
+	"metadata.name":      ConfigVariableClusterName, // CLUSTER_NAME
+	"metadata.namespace": ConfigVariableNamespace,   // NAMESPACE
+
+	"spec.clusterNetwork.pods.cidrBlocks":     ConfigVariableClusterCIDR, // CLUSTER_CIDR
+	"spec.clusterNetwork.services.cidrBlocks": ConfigVariableServiceCIDR, // SERVICE_CIDR
+
+	"spec.topology.class":   ConfigVariableClusterClass,      // CLUSTER_CLASS
+	"spec.topology.version": ConfigVariableKubernetesVersion, // KUBERNETES_VERSION
+
+	"spec.topology.controlPlane.replicas": ConfigVariableControlPlaneMachineCount, // CONTROL_PLANE_MACHINE_COUNT
+
+	"spec.topology.controlPlane.metadata.annotations.run.tanzu.vmware.com/resolve-os-image": "",
+
+	"spec.topology.variables.network.ipv6Primary":      TKGIPV6Primary,      // TKG_IPV6_PRIMARY
+	"spec.topology.variables.network.proxy":            TKGHTTPProxyEnabled, // TKG_HTTP_PROXY_ENABLED
+	"spec.topology.variables.network.proxy.httpProxy":  TKGHTTPProxy,        // TKG_HTTP_PROXY
+	"spec.topology.variables.network.proxy.httpsProxy": TKGHTTPSProxy,       // TKG_HTTPS_PROXY
+	"spec.topology.variables.network.proxy.noProxy":    TKGNoProxy,          // TKG_NO_PROXY
+
+	"spec.topology.variables.imageRepository.host":                     ConfigVariableCustomImageRepository,
+	"spec.topology.variables.imageRepository.tlsCertificateValidation": ConfigVariableCustomImageRepositorySkipTLSVerify,
+
+	"spec.topology.variables.clusterRole": ConfigVariableClusterRole, // TKG_CLUSTER_ROLE
+
+	"spec.topology.variables.auditLogging.enabled": EnableAuditLogging, // ENABLE_AUDIT_LOGGING
+
+	"spec.topology.variables.trust.proxy":           TKGProxyCACert,                                   // TKG_PROXY_CA_CERT
+	"spec.topology.variables.trust.imageRepository": ConfigVariableCustomImageRepositoryCaCertificate, // TKG_CUSTOM_IMAGE_REPOSITORY_CA_CERTIFICATE
+
+	"spec.topology.variables.apiServerPort": ConfigVariableClusterAPIServerPort, // CLUSTER_API_SERVER_PORT
+}
+
+// ClusterAttributesHigherPrecedenceToLowerMap has cluster class input attributes which
+// has higher precedence (as key's in this map) to attribute with lower precedence (as value's in this map)
+// For some properties (NODE_MACHINE_TYPE_1, NODE_MACHINE_TYPE_2, etc), Cluster YAML object may have values twice, this map holds attributes paths, key attribute path has higher
+// precedence than the value attribute path. So if the Cluster object has the values for both key and value attribute paths,
+// then we need to consider key attribute path (which has higher precedence).
+// eg: Key: "spec.topology.workers.machineDeployments.1.variables.overrides.NODE_MACHINE_TYPE", value: "spec.topology.variables.nodes.1.machineType"
+// 	these two key/value attribute paths mapped to NODE_MACHINE_TYPE_1 legacy variable, if these two attribute paths has values in Cluster Object
+// 	then need to consider higher precedence attribute path value which is key of ClusterAttributesHigherPrecedenceToLowerMap.
+
+var ClusterAttributesHigherPrecedenceToLowerMap = map[string]string{
+	"spec.topology.workers.machineDeployments.1.variables.overrides.NODE_MACHINE_TYPE": "spec.topology.variables.nodes.1.machineType",
+	"spec.topology.workers.machineDeployments.2.variables.overrides.NODE_MACHINE_TYPE": "spec.topology.variables.nodes.2.machineType",
+}
+
+// ClusterAttributesToLegacyVariablesMapAws has, AWS Cluster object attributes path mapped to legacy variable names.
+// spec.topology.variables.* mapped as per config_variable_association.star:get_aws_vars()
+// other attributes mapped as per infrastructure-aws/v*.*.*/yttcc/overlay.yaml
+var ClusterAttributesToLegacyVariablesMapAws = map[string]string{
+
+	"spec.topology.variables.region":     ConfigVariableAWSRegion,     // AWS_REGION
+	"spec.topology.variables.sshKeyName": ConfigVariableAWSSSHKeyName, // AWS_SSH_KEY_NAME
+
+	"spec.topology.variables.loadBalancerSchemeInternal": ConfigVariableAWSLoadBalancerSchemeInternal, // AWS_LOAD_BALANCER_SCHEME_INTERNAL
+
+	"spec.topology.variables.network.subnets.0.az":           ConfigVariableAWSNodeAz,           // AWS_NODE_AZ
+	"spec.topology.variables.network.subnets.0.private.cidr": ConfigVariableAWSPrivateNodeCIDR,  // AWS_PRIVATE_NODE_CIDR
+	"spec.topology.variables.network.subnets.0.private.id":   ConfigVariableAWSPrivateSubnetID,  // AWS_PRIVATE_SUBNET_ID
+	"spec.topology.variables.network.subnets.0.public.cidr":  ConfigVariableAWSPublicNodeCIDR,   // AWS_PUBLIC_NODE_CIDR
+	"spec.topology.variables.network.subnets.0.public.id":    ConfigVariableAWSPublicSubnetID,   // AWS_PUBLIC_SUBNET_ID
+	"spec.topology.variables.network.subnets.1.az":           ConfigVariableAWSNodeAz1,          // AWS_NODE_AZ_1
+	"spec.topology.variables.network.subnets.1.private.cidr": ConfigVariableAWSPrivateNodeCIDR1, // AWS_PRIVATE_NODE_CIDR_1
+	"spec.topology.variables.network.subnets.1.private.id":   ConfigVariableAWSPrivateSubnetID1, // AWS_PRIVATE_SUBNET_ID_1
+	"spec.topology.variables.network.subnets.1.public.cidr":  ConfigVariableAWSPublicNodeCIDR1,  // AWS_PUBLIC_NODE_CIDR_1
+	"spec.topology.variables.network.subnets.1.public.id":    ConfigVariableAWSPublicSubnetID1,  // AWS_PUBLIC_SUBNET_ID_1
+	"spec.topology.variables.network.subnets.2.az":           ConfigVariableAWSNodeAz2,          // AWS_NODE_AZ_2
+	"spec.topology.variables.network.subnets.2.private.cidr": ConfigVariableAWSPrivateNodeCIDR2, // AWS_PRIVATE_NODE_CIDR_2
+	"spec.topology.variables.network.subnets.2.private.id":   ConfigVariableAWSPrivateSubnetID2, // AWS_PRIVATE_SUBNET_ID_2
+	"spec.topology.variables.network.subnets.2.public.cidr":  ConfigVariableAWSPublicNodeCIDR2,  // AWS_PUBLIC_NODE_CIDR_2
+	"spec.topology.variables.network.subnets.2.public.id":    ConfigVariableAWSPublicSubnetID2,  // AWS_PUBLIC_SUBNET_ID_2
+
+	"spec.topology.variables.network.vpc.cidr":       ConfigVariableAWSVPCCIDR, // AWS_VPC_CIDR
+	"spec.topology.variables.network.vpc.existingID": ConfigVariableAWSVPCID,   // AWS_VPC_ID
+
+	"spec.topology.variables.network.securityGroupOverrides.bastion":      ConfigVariableAWSSecurityGroupBastion,      // AWS_SECURITY_GROUP_BASTION
+	"spec.topology.variables.network.securityGroupOverrides.apiServerLB":  ConfigVariableAWSSecurityGroupApiserverLb,  // AWS_SECURITY_GROUP_APISERVER_LB
+	"spec.topology.variables.network.securityGroupOverrides.lb":           ConfigVariableAWSSecurityGroupLb,           // AWS_SECURITY_GROUP_LB
+	"spec.topology.variables.network.securityGroupOverrides.controlPlane": ConfigVariableAWSSecurityGroupControlplane, // AWS_SECURITY_GROUP_CONTROLPLANE
+	"spec.topology.variables.network.securityGroupOverrides.node":         ConfigVariableAWSSecurityGroupNode,         // AWS_SECURITY_GROUP_NODE
+
+	"spec.topology.variables.bastion.enabled": ConfigVariableBastionHostEnabled, // BASTION_HOST_ENABLED
+
+	"spec.topology.variables.identityRef.name": ConfigVariableAWSIdentityRefName, // AWS_IDENTITY_REF_NAME
+	"spec.topology.variables.identityRef.kind": ConfigVariableAWSIdentityRefKind, // AWS_IDENTITY_REF_KIND
+
+	"spec.topology.variables.worker.instanceType":       ConfigVariableNodeMachineType,      // NODE_MACHINE_TYPE
+	"spec.topology.variables.worker.rootVolume.sizeGiB": ConfigVariableAWSNodeOsDiskSizeGib, // AWS_NODE_OS_DISK_SIZE_GIB
+
+	"spec.topology.variables.controlPlane.instanceType":       ConfigVariableControlPlaneMachineType,      // CONTROL_PLANE_MACHINE_TYPE
+	"spec.topology.variables.controlPlane.rootVolume.sizeGiB": ConfigVariableAWSControlplaneOsDiskSizeGib, // AWS_CONTROL_PLANE_OS_DISK_SIZE_GIB
+
+	TopologyWorkersMachineDeploymentsClass0:         "",
+	TopologyWorkersMachineDeploymentsName0:          "",
+	TopologyWorkersMachineDeploymentsReplicas0:      ConfigVariableWorkerMachineCount0, // WORKER_MACHINE_COUNT_0
+	TopologyWorkersMachineDeploymentsFailureDomain0: "",                                // AWS_NODE_AZ_0,
+
+	"spec.topology.workers.machineDeployments.0.metadata.annotations.run.tanzu.vmware.com/resolve-os-image": "",
+
+	TopologyWorkersMachineDeploymentsClass1:         "",
+	TopologyWorkersMachineDeploymentsName1:          "",
+	TopologyWorkersMachineDeploymentsReplicas1:      ConfigVariableWorkerMachineCount1, // WORKER_MACHINE_COUNT_1
+	TopologyWorkersMachineDeploymentsFailureDomain1: "",                                // AWS_NODE_AZ_1
+
+	"spec.topology.workers.machineDeployments.1.variables.overrides.worker.instanceType": ConfigVariableNodeMachineType1, // NODE_MACHINE_TYPE_1
+
+	TopologyWorkersMachineDeploymentsClass2:         "",
+	TopologyWorkersMachineDeploymentsName2:          "",
+	TopologyWorkersMachineDeploymentsReplicas2:      ConfigVariableWorkerMachineCount2, // WORKER_MACHINE_COUNT_2
+	TopologyWorkersMachineDeploymentsFailureDomain2: "",                                // AWS_NODE_AZ_2
+
+	"spec.topology.workers.machineDeployments.2.variables.overrides.worker.instanceType": ConfigVariableNodeMachineType2, // NODE_MACHINE_TYPE_2
+
+}
+
+// ClusterAttributesToLegacyVariablesMapAzure has, Azure Cluster object attributes path mapped to legacy variable names.
+// spec.topology.variables.* mapped as per config_variable_association.star:get_azure_vars()
+// other attributes mapped as per infrastructure-azure/v*.*.*/yttcc/overlay.yaml
+var ClusterAttributesToLegacyVariablesMapAzure = map[string]string{
+
+	"spec.topology.variables.network.vnet.cidrBlocks":    ConfigVariableAzureVnetCidr,          // AZURE_VNET_CIDR
+	"spec.topology.variables.network.vnet.name":          ConfigVariableAzureVnetName,          // AZURE_VNET_NAME
+	"spec.topology.variables.network.vnet.resourceGroup": ConfigVariableAzureVnetResourceGroup, // AZURE_VNET_RESOURCE_GROUP
+
+	"spec.topology.variables.location":          ConfigVariableAzureLocation,          // AZURE_LOCATION
+	"spec.topology.variables.resourceGroup":     ConfigVariableAzureResourceGroup,     // AZURE_RESOURCE_GROUP
+	"spec.topology.variables.subscriptionID":    ConfigVariableAzureSubscriptionID,    // AZURE_SUBSCRIPTION_ID
+	"spec.topology.variables.environment":       ConfigVariableAzureEnvironment,       // AZURE_ENVIRONMENT
+	"spec.topology.variables.sshPublicKey":      ConfigVariableAzureSSHPublicKeyB64,   // AZURE_SSH_PUBLIC_KEY_B64
+	"spec.topology.variables.frontendPrivateIP": ConfigVariableAzureFrontendPrivateIP, // AZURE_FRONTEND_PRIVATE_IP
+	"spec.topology.variables.customTags":        ConfigVariableAzureCustomTags,        // AZURE_CUSTOM_TAGS
+
+	"spec.topology.variables.acceleratedNetworking.enabled": ConfigVariableAzureEnableAcceleratedNetworking, // AZURE_ENABLE_ACCELERATED_NETWORKING
+	"spec.topology.variables.privateCluster.enabled":        ConfigVariableAzureEnablePrivateCluster,        // AZURE_ENABLE_PRIVATE_CLUSTER
+
+	"spec.topology.variables.identityRef.name":      ConfigVariableAzureIdentityName,      // AZURE_IDENTITY_NAME
+	"spec.topology.variables.identityRef.namespace": ConfigVariableAzureIdentityNamespace, // AZURE_IDENTITY_NAMESPACE
+
+	"spec.topology.variables.controlPlane.vmSize":            ConfigVariableAzureCPMachineType,               // AZURE_CONTROL_PLANE_MACHINE_TYPE
+	"spec.topology.variables.controlPlane.dataDisks.sizeGiB": ConfigVariableAzureControlPlaneDataDiskSizeGib, // AZURE_CONTROL_PLANE_DATA_DISK_SIZE_GIB
+
+	"spec.topology.variables.controlPlane.osDisk.sizeGiB":            ConfigVariableAzureControlPlaneOsDiskSizeGib,            // AZURE_CONTROL_PLANE_OS_DISK_SIZE_GIB
+	"spec.topology.variables.controlPlane.osDisk.storageAccountType": ConfigVariableAzureControlPlaneOsDiskStorageAccountType, // AZURE_CONTROL_PLANE_OS_DISK_STORAGE_ACCOUNT_TYPE
+
+	"spec.topology.variables.controlPlane.subnet.name":          ConfigVariableAzureControlPlaneSubnetName,          // AZURE_CONTROL_PLANE_SUBNET_NAME
+	"spec.topology.variables.controlPlane.subnet.cidr":          ConfigVariableAzureControlPlaneSubnetCidr,          // AZURE_CONTROL_PLANE_SUBNET_CIDR
+	"spec.topology.variables.controlPlane.subnet.securityGroup": ConfigVariableAzureControlPlaneSubnetSecurityGroup, // AZURE_CONTROL_PLANE_SUBNET_SECURITY_GROUP
+
+	"spec.topology.variables.controlPlane.outboundLB.enabled":         ConfigVariableAzureControlPlaneOutboundLb,                // AZURE_ENABLE_CONTROL_PLANE_OUTBOUND_LB
+	"spec.topology.variables.controlPlane.outboundLB.frontendIPCount": ConfigVariableAzureControlPlaneOutboundLbFrontendIPCount, // AZURE_CONTROL_PLANE_OUTBOUND_LB_FRONTEND_IP_COUNT
+
+	"spec.topology.variables.worker.vmSize":                    ConfigVariableAzureNodeMachineType,              // AZURE_NODE_MACHINE_TYPE
+	"spec.topology.variables.worker.osDisk.sizeGiB":            ConfigVariableAzureNodeOsDiskSizeGib,            // AZURE_NODE_OS_DISK_SIZE_GIB
+	"spec.topology.variables.worker.osDisk.storageAccountType": ConfigVariableAzureNodeOsDiskStorageAccountType, // AZURE_NODE_OS_DISK_STORAGE_ACCOUNT_TYPE
+	"spec.topology.variables.worker.dataDisks.sizeGiB":         ConfigVariableAzureNodeDataDiskSizeGib,          // AZURE_NODE_DATA_DISK_SIZE_GIB
+
+	"spec.topology.variables.worker.subnet.cidr":          ConfigVariableAzureWorkerNodeSubnetCidr,    // AZURE_NODE_SUBNET_CIDR
+	"spec.topology.variables.worker.subnet.name":          ConfigVariableAzureWorkerSubnetName,        // AZURE_NODE_SUBNET_NAME
+	"spec.topology.variables.worker.subnet.securityGroup": ConfigVariableAzureNodeSubnetSecurityGroup, // AZURE_NODE_SUBNET_SECURITY_GROUP
+
+	"spec.topology.variables.worker.outboundLB.enabled":              ConfigVariableAzureEnableNodeOutboundLb,               // AZURE_ENABLE_NODE_OUTBOUND_LB
+	"spec.topology.variables.worker.outboundLB.frontendIPCount":      ConfigVariableAzureNodeOutboundLbFrontendIPCount,      // AZURE_NODE_OUTBOUND_LB_FRONTEND_IP_COUNT
+	"spec.topology.variables.worker.outboundLB.idleTimeoutInMinutes": ConfigVariableAzureNodeOutboundLbIdleTimeoutInMinutes, // AZURE_NODE_OUTBOUND_LB_IDLE_TIMEOUT_IN_MINUTES
+
+	TopologyWorkersMachineDeploymentsClass0:         "",
+	TopologyWorkersMachineDeploymentsName0:          "",
+	TopologyWorkersMachineDeploymentsReplicas0:      ConfigVariableWorkerMachineCount0,
+	TopologyWorkersMachineDeploymentsFailureDomain0: ConfigVariableAzureAZ,
+
+	"spec.topology.workers.machineDeployments.0.metadata.annotations.run.tanzu.vmware.com/resolve-os-image": "",
+
+	TopologyWorkersMachineDeploymentsClass1:         "",
+	TopologyWorkersMachineDeploymentsName1:          "",
+	TopologyWorkersMachineDeploymentsReplicas1:      ConfigVariableWorkerMachineCount1,
+	TopologyWorkersMachineDeploymentsFailureDomain1: ConfigVariableAzureAZ1,
+
+	"spec.topology.workers.machineDeployments.1.variables.overrides.worker.vmSize": ConfigVariableNodeMachineType1,
+
+	TopologyWorkersMachineDeploymentsClass2:         "",
+	TopologyWorkersMachineDeploymentsName2:          "",
+	TopologyWorkersMachineDeploymentsReplicas2:      ConfigVariableWorkerMachineCount2,
+	TopologyWorkersMachineDeploymentsFailureDomain2: ConfigVariableAzureAZ2,
+
+	"spec.topology.workers.machineDeployments.2.variables.overrides.worker.vmSize": ConfigVariableNodeMachineType2,
+}
+
+// ClusterAttributesToLegacyVariablesMapVsphere has, Vsphere Cluster object attributes path mapped to legacy variable names.
+// spec.topology.variables.* mapped as per config_variable_association.star:get_vsphere_vars()
+// other attributes mapped as per infrastructure-vsphere/v*.*.*/yttcc/overlay.yaml
+var ClusterAttributesToLegacyVariablesMapVsphere = map[string]string{
+
+	"spec.topology.variables.apiServerEndpoint":      ConfigVariableVsphereControlPlaneEndpoint, // VSPHERE_CONTROL_PLANE_ENDPOINT
+	"spec.topology.variables.vipNetworkInterface":    ConfigVariableVipNetworkInterface,         // VIP_NETWORK_INTERFACE
+	"spec.topology.variables.aviAPIServerHAProvider": ConfigVariableVsphereHaProvider,           // AVI_CONTROL_PLANE_HA_PROVIDER
+
+	"spec.topology.variables.vcenter.cloneMode":     ConfigVariableVsphereCloneMode,     // VSPHERE_CLONE_MODE
+	"spec.topology.variables.vcenter.network":       ConfigVariableVsphereNetwork,       // VSPHERE_NETWORK
+	"spec.topology.variables.vcenter.resourcePool":  ConfigVariableVsphereResourcePool,  // VSPHERE_RESOURCE_POOL
+	"spec.topology.variables.vcenter.template":      ConfigVariableVsphereTemplate,      // VSPHERE_TEMPLATE
+	"spec.topology.variables.vcenter.tlsThumbprint": ConfigVariableVsphereTLSThumbprint, // VSPHERE_TLS_THUMBPRINT
+	"spec.topology.variables.vcenter.datacenter":    ConfigVariableVsphereDatacenter,    // VSPHERE_DATACENTER
+	"spec.topology.variables.vcenter.datastore":     ConfigVariableVsphereDatastore,     // VSPHERE_DATASTORE
+	"spec.topology.variables.vcenter.folder":        ConfigVariableVsphereFolder,        // VSPHERE_FOLDER
+	"spec.topology.variables.vcenter.server":        ConfigVariableVsphereServer,        // VSPHERE_SERVER
+
+	"spec.topology.variables.user.sshAuthorizedKeys": ConfigVariableVsphereSSHAuthorizedKey, // VSPHERE_SSH_AUTHORIZED_KEY
+
+	"spec.topology.variables.controlPlane.machine.diskGiB":     ConfigVariableVsphereCPDiskGib,            // VSPHERE_CONTROL_PLANE_DISK_GIB
+	"spec.topology.variables.controlPlane.machine.memoryMiB":   ConfigVariableVsphereCPMemMib,             // VSPHERE_CONTROL_PLANE_MEM_MIB
+	"spec.topology.variables.controlPlane.machine.numCPUs":     ConfigVariableVsphereCPNumCpus,            // VSPHERE_CONTROL_PLANE_NUM_CPUS
+	"spec.topology.variables.controlPlane.network.nameservers": ConfigVariableControlPlaneNodeNameservers, // CONTROL_PLANE_NODE_NAMESERVERS
+
+	"spec.topology.variables.worker.machine.diskGiB":     ConfigVariableVsphereWorkerDiskGib,  // VSPHERE_WORKER_DISK_GIB
+	"spec.topology.variables.worker.machine.memoryMiB":   ConfigVariableVsphereWorkerMemMib,   // VSPHERE_WORKER_MEM_MIB
+	"spec.topology.variables.worker.machine.numCPUs":     ConfigVariableVsphereWorkerNumCpus,  // VSPHERE_WORKER_NUM_CPUS
+	"spec.topology.variables.worker.network.nameservers": ConfigVariableWorkerNodeNameservers, // WORKER_NODE_NAMESERVERS
+
+	TopologyWorkersMachineDeploymentsClass0:         "",
+	TopologyWorkersMachineDeploymentsName0:          "",
+	TopologyWorkersMachineDeploymentsReplicas0:      ConfigVariableWorkerMachineCount,
+	TopologyWorkersMachineDeploymentsFailureDomain0: ConfigVariableVsphereAz0,
+
+	TopologyWorkersMachineDeploymentsClass1:         "",
+	TopologyWorkersMachineDeploymentsName1:          "",
+	TopologyWorkersMachineDeploymentsReplicas1:      ConfigVariableWorkerMachineCount1,
+	TopologyWorkersMachineDeploymentsFailureDomain1: ConfigVariableVsphereAz1,
+
+	TopologyWorkersMachineDeploymentsClass2:         "",
+	TopologyWorkersMachineDeploymentsName2:          "",
+	TopologyWorkersMachineDeploymentsReplicas2:      ConfigVariableWorkerMachineCount2,
+	TopologyWorkersMachineDeploymentsFailureDomain2: ConfigVariableVsphereAz2,
+}
+
+// ClusterAttributesToLegacyVariablesMapDocker has, Docker Cluster object attributes path mapped to legacy variable names.
+var ClusterAttributesToLegacyVariablesMapDocker = map[string]string{}
+
+// ClusterAttributesWithArrayTypeValue has, list of Cluster attributes paths, which value type is array list
+var ClusterAttributesWithArrayTypeValue = map[string]bool{
+	"spec.clusterNetwork.pods.cidrBlocks":             true,
+	"spec.clusterNetwork.services.cidrBlocks":         true,
+	"spec.topology.variables.network.proxy.noProxy":   true,
+	"spec.topology.variables.user.sshAuthorizedKeys":  true,
+	"spec.topology.variables.network.vnet.cidrBlocks": true,
+}
+
+// Cluster class variables constants
+const (
+	RegexpMachineDeploymentsOverrides = `spec.topology.workers.machineDeployments.[0-9].variables.overrides`
+	RegexpTopologyClassValue          = `tkg-(aws|azure|vsphere)-default`
+
+	TopologyVariablesNetworkSubnets   = "spec.topology.variables.network.subnets"
+	TopologyVariablesNodes            = "spec.topology.variables.nodes"
+	TopologyVariablesTrust            = "spec.topology.variables.trust"
+	TopologyWorkersMachineDeployments = "spec.topology.workers.machineDeployments"
+	TopologyClass                     = "spec.topology.class"
+	TopologyVariables                 = "spec.topology.variables"
+
+	TopologyWorkersMachineDeploymentsClass0         = "spec.topology.workers.machineDeployments.0.class"
+	TopologyWorkersMachineDeploymentsName0          = "spec.topology.workers.machineDeployments.0.name"
+	TopologyWorkersMachineDeploymentsReplicas0      = "spec.topology.workers.machineDeployments.0.replicas"
+	TopologyWorkersMachineDeploymentsFailureDomain0 = "spec.topology.workers.machineDeployments.0.failureDomain"
+
+	TopologyWorkersMachineDeploymentsClass1         = "spec.topology.workers.machineDeployments.1.class"
+	TopologyWorkersMachineDeploymentsName1          = "spec.topology.workers.machineDeployments.1.name"
+	TopologyWorkersMachineDeploymentsReplicas1      = "spec.topology.workers.machineDeployments.1.replicas"
+	TopologyWorkersMachineDeploymentsFailureDomain1 = "spec.topology.workers.machineDeployments.1.failureDomain"
+
+	TopologyWorkersMachineDeploymentsClass2         = "spec.topology.workers.machineDeployments.2.class"
+	TopologyWorkersMachineDeploymentsName2          = "spec.topology.workers.machineDeployments.2.name"
+	TopologyWorkersMachineDeploymentsReplicas2      = "spec.topology.workers.machineDeployments.2.replicas"
+	TopologyWorkersMachineDeploymentsFailureDomain2 = "spec.topology.workers.machineDeployments.2.failureDomain"
+
+	SPEC = "spec"
+
+	TopologyClassIncorrectValueErrMsg = "input cluster class file, attribute spec.topology.class has no value or incorrect value or not following correct naming convension"
+)
+
+// InfrastructureSpecificVariableMappingMap has, infra name to variable mapping map, which makes easy to get infra specific mapping map
+var InfrastructureSpecificVariableMappingMap = map[string]map[string]string{
+	InfrastructureProviderVSphere: ClusterAttributesToLegacyVariablesMapVsphere,
+	InfrastructureProviderAWS:     ClusterAttributesToLegacyVariablesMapAws,
+	InfrastructureProviderAzure:   ClusterAttributesToLegacyVariablesMapAzure,
+	InfrastructureProviderDocker:  ClusterAttributesToLegacyVariablesMapDocker,
+}
+
+// During initialization, combine common map to infra specific map's, which reduces code where we use infra maps
+func init() {
+	for key, value := range ClusterAttributesToLegacyVariablesMapCommon {
+		ClusterAttributesToLegacyVariablesMapAws[key] = value
+		ClusterAttributesToLegacyVariablesMapAzure[key] = value
+		ClusterAttributesToLegacyVariablesMapVsphere[key] = value
+		ClusterAttributesToLegacyVariablesMapDocker[key] = value
+	}
+}
diff --git a/pkg/v1/tkg/constants/config_variables.go b/pkg/v1/tkg/constants/config_variables.go
index fdf5a9995d..8fd97b751a 100644
--- a/pkg/v1/tkg/constants/config_variables.go
+++ b/pkg/v1/tkg/constants/config_variables.go
@@ -15,6 +15,9 @@ const (
 	ConfigVariableDefaultStandaloneDiscoveryImageTag  = "TKG_DEFAULT_STANDALONE_DISCOVERY_IMAGE_TAG"
 	ConfigVariableDefaultStandaloneDiscoveryType      = "TKG_DEFAULT_STANDALONE_DISCOVERY_TYPE"
 	ConfigVariableDefaultStandaloneDiscoveryLocalPath = "TKG_DEFAULT_STANDALONE_DISCOVERY_LOCAL_PATH"
+	ConfigVariableClusterAPIServerPort                = "CLUSTER_API_SERVER_PORT"
+	ConfigVariableBastionHostEnabled                  = "BASTION_HOST_ENABLED"
+	ConfigVariableVipNetworkInterface                 = "VIP_NETWORK_INTERFACE"
 
 	ConfigVariableAWSRegion          = "AWS_REGION"
 	ConfigVariableAWSSecretAccessKey = "AWS_SECRET_ACCESS_KEY" //nolint:gosec
@@ -23,24 +26,41 @@ const (
 	ConfigVariableAWSProfile         = "AWS_PROFILE"
 	ConfigVariableAWSB64Credentials  = "AWS_B64ENCODED_CREDENTIALS" //nolint:gosec
 	ConfigVariableAWSVPCID           = "AWS_VPC_ID"
-
-	ConfigVariableAWSPublicNodeCIDR   = "AWS_PUBLIC_NODE_CIDR"
-	ConfigVariableAWSPrivateNodeCIDR  = "AWS_PRIVATE_NODE_CIDR"
-	ConfigVariableAWSPublicNodeCIDR1  = "AWS_PUBLIC_NODE_CIDR_1"
-	ConfigVariableAWSPrivateNodeCIDR1 = "AWS_PRIVATE_NODE_CIDR_1"
-	ConfigVariableAWSPublicNodeCIDR2  = "AWS_PUBLIC_NODE_CIDR_2"
-	ConfigVariableAWSPrivateNodeCIDR2 = "AWS_PRIVATE_NODE_CIDR_2"
-	ConfigVariableAWSPublicSubnetID   = "AWS_PUBLIC_SUBNET_ID"
-	ConfigVariableAWSPrivateSubnetID  = "AWS_PRIVATE_SUBNET_ID"
-	ConfigVariableAWSPublicSubnetID1  = "AWS_PUBLIC_SUBNET_ID_1"
-	ConfigVariableAWSPrivateSubnetID1 = "AWS_PRIVATE_SUBNET_ID_1"
-	ConfigVariableAWSPublicSubnetID2  = "AWS_PUBLIC_SUBNET_ID_2"
-	ConfigVariableAWSPrivateSubnetID2 = "AWS_PRIVATE_SUBNET_ID_2"
-	ConfigVariableAWSVPCCIDR          = "AWS_VPC_CIDR"
-	ConfigVariableAWSNodeAz           = "AWS_NODE_AZ"
-	ConfigVariableAWSNodeAz1          = "AWS_NODE_AZ_1"
-	ConfigVariableAWSAMIID            = "AWS_AMI_ID"
-
+	ConfigVariableAWSSSHKeyName      = "AWS_SSH_KEY_NAME"
+
+	ConfigVariableAWSPublicNodeCIDR             = "AWS_PUBLIC_NODE_CIDR"
+	ConfigVariableAWSPrivateNodeCIDR            = "AWS_PRIVATE_NODE_CIDR"
+	ConfigVariableAWSPublicNodeCIDR1            = "AWS_PUBLIC_NODE_CIDR_1"
+	ConfigVariableAWSPrivateNodeCIDR1           = "AWS_PRIVATE_NODE_CIDR_1"
+	ConfigVariableAWSPublicNodeCIDR2            = "AWS_PUBLIC_NODE_CIDR_2"
+	ConfigVariableAWSPrivateNodeCIDR2           = "AWS_PRIVATE_NODE_CIDR_2"
+	ConfigVariableAWSPublicSubnetID             = "AWS_PUBLIC_SUBNET_ID"
+	ConfigVariableAWSPrivateSubnetID            = "AWS_PRIVATE_SUBNET_ID"
+	ConfigVariableAWSPublicSubnetID1            = "AWS_PUBLIC_SUBNET_ID_1"
+	ConfigVariableAWSPrivateSubnetID1           = "AWS_PRIVATE_SUBNET_ID_1"
+	ConfigVariableAWSPublicSubnetID2            = "AWS_PUBLIC_SUBNET_ID_2"
+	ConfigVariableAWSPrivateSubnetID2           = "AWS_PRIVATE_SUBNET_ID_2"
+	ConfigVariableAWSVPCCIDR                    = "AWS_VPC_CIDR"
+	ConfigVariableAWSNodeAz                     = "AWS_NODE_AZ"
+	ConfigVariableAWSNodeAz1                    = "AWS_NODE_AZ_1"
+	ConfigVariableAWSNodeAz2                    = "AWS_NODE_AZ_2"
+	ConfigVariableAWSAMIID                      = "AWS_AMI_ID"
+	ConfigVariableAWSLoadBalancerSchemeInternal = "AWS_LOAD_BALANCER_SCHEME_INTERNAL"
+	ConfigVariableAWSNodeOsDiskSizeGib          = "AWS_NODE_OS_DISK_SIZE_GIB"
+
+	ConfigVariableAWSIdentityRefKind           = "AWS_IDENTITY_REF_KIND"
+	ConfigVariableAWSIdentityRefName           = "AWS_IDENTITY_REF_NAME"
+	ConfigVariableAWSSecurityGroupNode         = "AWS_SECURITY_GROUP_NODE"
+	ConfigVariableAWSSecurityGroupApiserverLb  = "AWS_SECURITY_GROUP_APISERVER_LB"
+	ConfigVariableAWSSecurityGroupBastion      = "AWS_SECURITY_GROUP_BASTION"
+	ConfigVariableAWSSecurityGroupControlplane = "AWS_SECURITY_GROUP_CONTROLPLANE"
+	ConfigVariableAWSSecurityGroupLb           = "AWS_SECURITY_GROUP_LB"
+	ConfigVariableAWSControlplaneOsDiskSizeGib = "AWS_CONTROL_PLANE_OS_DISK_SIZE_GIB"
+
+	ConfigVariableVsphereAz0                  = "VSPHERE_AZ_0"
+	ConfigVariableVsphereAz1                  = "VSPHERE_AZ_1"
+	ConfigVariableVsphereAz2                  = "VSPHERE_AZ_2"
+	ConfigVariableVsphereCloneMode            = "VSPHERE_CLONE_MODE"
 	ConfigVariableVsphereControlPlaneEndpoint = "VSPHERE_CONTROL_PLANE_ENDPOINT"
 	ConfigVariableVsphereServer               = "VSPHERE_SERVER"
 	ConfigVariableVsphereUsername             = "VSPHERE_USERNAME"
@@ -68,37 +88,64 @@ const (
 	ConfigVariableVsphereNetwork              = "VSPHERE_NETWORK"
 	ConfigVariableVsphereHaProvider           = "AVI_CONTROL_PLANE_HA_PROVIDER"
 
-	ConfigVariableAzureLocation               = "AZURE_LOCATION"
-	ConfigVariableAzureImageID                = "AZURE_IMAGE_ID"
-	ConfigVariableAzureImagePublisher         = "AZURE_IMAGE_PUBLISHER"
-	ConfigVariableAzureImageOffer             = "AZURE_IMAGE_OFFER"
-	ConfigVariableAzureImageSku               = "AZURE_IMAGE_SKU"
-	ConfigVariableAzureImageVersion           = "AZURE_IMAGE_VERSION"
-	ConfigVariableAzureImageThirdParty        = "AZURE_IMAGE_THIRD_PARTY"
-	ConfigVariableAzureImageResourceGroup     = "AZURE_IMAGE_RESOURCE_GROUP"
-	ConfigVariableAzureImageName              = "AZURE_IMAGE_NAME"
-	ConfigVariableAzureImageSubscriptionID    = "AZURE_IMAGE_SUBSCRIPTION_ID"
-	ConfigVariableAzureImageGallery           = "AZURE_IMAGE_GALLERY"
-	ConfigVariableAzureSubscriptionIDB64      = "AZURE_SUBSCRIPTION_ID_B64"
-	ConfigVariableAzureTenantIDB64            = "AZURE_TENANT_ID_B64"
-	ConfigVariableAzureClientSecretB64        = "AZURE_CLIENT_SECRET_B64" //nolint:gosec
-	ConfigVariableAzureClientIDB64            = "AZURE_CLIENT_ID_B64"
-	ConfigVariableAzureSubscriptionID         = "AZURE_SUBSCRIPTION_ID"
-	ConfigVariableAzureTenantID               = "AZURE_TENANT_ID"
-	ConfigVariableAzureClientSecret           = "AZURE_CLIENT_SECRET" //nolint:gosec
-	ConfigVariableAzureClientID               = "AZURE_CLIENT_ID"
-	ConfigVariableAzureResourceGroup          = "AZURE_RESOURCE_GROUP"
-	ConfigVariableAzureVnetName               = "AZURE_VNET_NAME"
-	ConfigVariableAzureVnetResourceGroup      = "AZURE_VNET_RESOURCE_GROUP"
-	ConfigVariableAzureVnetCidr               = "AZURE_VNET_CIDR"
-	ConfigVariableAzureControlPlaneSubnet     = "AZURE_CONTROL_PLANE_SUBNET_NAME"
-	ConfigVariableAzureWorkerSubnet           = "AZURE_NODE_SUBNET_NAME"
-	ConfigVariableAzureControlPlaneSubnetCidr = "AZURE_CONTROL_PLANE_SUBNET_CIDR"
-	ConfigVariableAzureWorkerNodeSubnetCidr   = "AZURE_NODE_SUBNET_CIDR"
-	ConfigVariableAzureSSHPublicKeyB64        = "AZURE_SSH_PUBLIC_KEY_B64"
-	ConfigVariableAzureCPMachineType          = "AZURE_CONTROL_PLANE_MACHINE_TYPE"
-	ConfigVariableAzureNodeMachineType        = "AZURE_NODE_MACHINE_TYPE"
-	ConfigVariableAzureEnvironment            = "AZURE_ENVIRONMENT"
+	ConfigVariableAzureControlPlaneSubnet                    = "AZURE_CONTROL_PLANE_SUBNET_NAME"
+	ConfigVariableAzureControlPlaneSubnetName                = "AZURE_CONTROL_PLANE_SUBNET_NAME"
+	ConfigVariableAzureControlPlaneSubnetCidr                = "AZURE_CONTROL_PLANE_SUBNET_CIDR"
+	ConfigVariableAzureCPMachineType                         = "AZURE_CONTROL_PLANE_MACHINE_TYPE"
+	ConfigVariableAzureControlPlaneDataDiskSizeGib           = "AZURE_CONTROL_PLANE_DATA_DISK_SIZE_GIB"
+	ConfigVariableAzureControlPlaneOsDiskStorageAccountType  = "AZURE_CONTROL_PLANE_OS_DISK_STORAGE_ACCOUNT_TYPE"
+	ConfigVariableAzureControlPlaneOsDiskSizeGib             = "AZURE_CONTROL_PLANE_OS_DISK_SIZE_GIB"
+	ConfigVariableAzureControlPlaneOutboundLbFrontendIPCount = "AZURE_CONTROL_PLANE_OUTBOUND_LB_FRONTEND_IP_COUNT"
+	ConfigVariableAzureControlPlaneOutboundLb                = "AZURE_ENABLE_CONTROL_PLANE_OUTBOUND_LB"
+	ConfigVariableAzureControlPlaneSubnetSecurityGroup       = "AZURE_CONTROL_PLANE_SUBNET_SECURITY_GROUP"
+
+	ConfigVariableAzureCustomTags                  = "AZURE_CUSTOM_TAGS"
+	ConfigVariableAzureEnableAcceleratedNetworking = "AZURE_ENABLE_ACCELERATED_NETWORKING"
+	ConfigVariableAzureEnablePrivateCluster        = "AZURE_ENABLE_PRIVATE_CLUSTER"
+	ConfigVariableAzureFrontendPrivateIP           = "AZURE_FRONTEND_PRIVATE_IP"
+	ConfigVariableAzureLocation                    = "AZURE_LOCATION"
+	ConfigVariableAzureIdentityName                = "AZURE_IDENTITY_NAME"
+	ConfigVariableAzureIdentityNamespace           = "AZURE_IDENTITY_NAMESPACE"
+	ConfigVariableAzureImageID                     = "AZURE_IMAGE_ID"
+	ConfigVariableAzureImagePublisher              = "AZURE_IMAGE_PUBLISHER"
+	ConfigVariableAzureImageOffer                  = "AZURE_IMAGE_OFFER"
+	ConfigVariableAzureImageSku                    = "AZURE_IMAGE_SKU"
+	ConfigVariableAzureImageVersion                = "AZURE_IMAGE_VERSION"
+	ConfigVariableAzureImageThirdParty             = "AZURE_IMAGE_THIRD_PARTY"
+	ConfigVariableAzureImageResourceGroup          = "AZURE_IMAGE_RESOURCE_GROUP"
+	ConfigVariableAzureImageName                   = "AZURE_IMAGE_NAME"
+	ConfigVariableAzureImageSubscriptionID         = "AZURE_IMAGE_SUBSCRIPTION_ID"
+	ConfigVariableAzureImageGallery                = "AZURE_IMAGE_GALLERY"
+	ConfigVariableAzureSubscriptionIDB64           = "AZURE_SUBSCRIPTION_ID_B64"
+	ConfigVariableAzureTenantIDB64                 = "AZURE_TENANT_ID_B64"
+	ConfigVariableAzureClientSecretB64             = "AZURE_CLIENT_SECRET_B64" //nolint:gosec
+	ConfigVariableAzureClientIDB64                 = "AZURE_CLIENT_ID_B64"
+	ConfigVariableAzureSubscriptionID              = "AZURE_SUBSCRIPTION_ID"
+	ConfigVariableAzureTenantID                    = "AZURE_TENANT_ID"
+	ConfigVariableAzureClientSecret                = "AZURE_CLIENT_SECRET" //nolint:gosec
+	ConfigVariableAzureClientID                    = "AZURE_CLIENT_ID"
+	ConfigVariableAzureResourceGroup               = "AZURE_RESOURCE_GROUP"
+	ConfigVariableAzureVnetName                    = "AZURE_VNET_NAME"
+	ConfigVariableAzureVnetResourceGroup           = "AZURE_VNET_RESOURCE_GROUP"
+	ConfigVariableAzureVnetCidr                    = "AZURE_VNET_CIDR"
+
+	ConfigVariableAzureWorkerSubnet                       = "AZURE_NODE_SUBNET_NAME"
+	ConfigVariableAzureWorkerSubnetName                   = "AZURE_NODE_SUBNET_NAME"
+	ConfigVariableAzureAZ                                 = "AZURE_NODE_AZ"
+	ConfigVariableAzureAZ1                                = "AZURE_NODE_AZ_1"
+	ConfigVariableAzureAZ2                                = "AZURE_NODE_AZ_2"
+	ConfigVariableAzureNodeOsDiskSizeGib                  = "AZURE_NODE_OS_DISK_SIZE_GIB"
+	ConfigVariableAzureNodeOsDiskStorageAccountType       = "AZURE_NODE_OS_DISK_STORAGE_ACCOUNT_TYPE"
+	ConfigVariableAzureEnableNodeDataDisk                 = "AZURE_ENABLE_NODE_DATA_DISK"
+	ConfigVariableAzureNodeDataDiskSizeGib                = "AZURE_NODE_DATA_DISK_SIZE_GIB"
+	ConfigVariableAzureNodeSubnetSecurityGroup            = "AZURE_NODE_SUBNET_SECURITY_GROUP"
+	ConfigVariableAzureEnableNodeOutboundLb               = "AZURE_ENABLE_NODE_OUTBOUND_LB"
+	ConfigVariableAzureNodeOutboundLbFrontendIPCount      = "AZURE_NODE_OUTBOUND_LB_FRONTEND_IP_COUNT"
+	ConfigVariableAzureNodeOutboundLbIdleTimeoutInMinutes = "AZURE_NODE_OUTBOUND_LB_IDLE_TIMEOUT_IN_MINUTES"
+	ConfigVariableAzureWorkerNodeSubnetCidr               = "AZURE_NODE_SUBNET_CIDR"
+	ConfigVariableAzureSSHPublicKeyB64                    = "AZURE_SSH_PUBLIC_KEY_B64"
+	ConfigVariableAzureNodeMachineType                    = "AZURE_NODE_MACHINE_TYPE"
+	ConfigVariableAzureEnvironment                        = "AZURE_ENVIRONMENT"
 
 	ConfigVariableDockerMachineTemplateImage = "DOCKER_MACHINE_TEMPLATE_IMAGE"
 
@@ -116,14 +163,16 @@ const (
 	ConfigVariableDisableTMCCloudPermissions = "DISABLE_TMC_CLOUD_PERMISSIONS"
 
 	ConfigVariableControlPlaneMachineCount = "CONTROL_PLANE_MACHINE_COUNT"
-	ConfigVariableWorkerMachineCount       = "WORKER_MACHINE_COUNT"
-	ConfigVariableWorkerMachineCount0      = "WORKER_MACHINE_COUNT_0"
-	ConfigVariableWorkerMachineCount1      = "WORKER_MACHINE_COUNT_1"
-	ConfigVariableWorkerMachineCount2      = "WORKER_MACHINE_COUNT_2"
-	ConfigVariableNodeMachineType          = "NODE_MACHINE_TYPE"
-	ConfigVariableNodeMachineType1         = "NODE_MACHINE_TYPE_1"
-	ConfigVariableNodeMachineType2         = "NODE_MACHINE_TYPE_2"
-	ConfigVariableCPMachineType            = "CONTROL_PLANE_MACHINE_TYPE"
+	ConfigVariableControlPlaneMachineType  = "CONTROL_PLANE_MACHINE_TYPE"
+
+	ConfigVariableWorkerMachineCount  = "WORKER_MACHINE_COUNT"
+	ConfigVariableWorkerMachineCount0 = "WORKER_MACHINE_COUNT_0"
+	ConfigVariableWorkerMachineCount1 = "WORKER_MACHINE_COUNT_1"
+	ConfigVariableWorkerMachineCount2 = "WORKER_MACHINE_COUNT_2"
+	ConfigVariableNodeMachineType     = "NODE_MACHINE_TYPE"
+	ConfigVariableNodeMachineType1    = "NODE_MACHINE_TYPE_1"
+	ConfigVariableNodeMachineType2    = "NODE_MACHINE_TYPE_2"
+	ConfigVariableCPMachineType       = "CONTROL_PLANE_MACHINE_TYPE"
 
 	ConfigVariableNamespace            = "NAMESPACE"
 	ConfigVariableEnableClusterOptions = "ENABLE_CLUSTER_OPTIONS"
@@ -133,6 +182,8 @@ const (
 	TKGHTTPProxyEnabled = "TKG_HTTP_PROXY_ENABLED"
 	TKGNoProxy          = "TKG_NO_PROXY"
 	TKGProxyCACert      = "TKG_PROXY_CA_CERT"
+	EnableAuditLogging  = "ENABLE_AUDIT_LOGGING"
+	TKGIPFamily         = "TKG_IP_FAMILY"
 
 	ConfigVariableOSName    = "OS_NAME"
 	ConfigVariableOSVersion = "OS_VERSION"
@@ -144,6 +195,7 @@ const (
 	ConfigVariableCoreDNSIP = "CORE_DNS_IP"
 
 	ConfigVariableIPFamily = "TKG_IP_FAMILY"
+	TKGIPV6Primary         = "TKG_IPV6_PRIMARY"
 
 	ConfigVariableControlPlaneNodeNameservers = "CONTROL_PLANE_NODE_NAMESERVERS"
 	ConfigVariableWorkerNodeNameservers       = "WORKER_NODE_NAMESERVERS"
diff --git a/pkg/v1/tkg/fakes/config/ccluster1_clusterOnly.yaml b/pkg/v1/tkg/fakes/config/ccluster1_clusterOnly.yaml
deleted file mode 100644
index 8ac0dcede8..0000000000
--- a/pkg/v1/tkg/fakes/config/ccluster1_clusterOnly.yaml
+++ /dev/null
@@ -1,91 +0,0 @@
-apiVersion: cluster.x-k8s.io/v1beta1
-kind: Cluster
-metadata:
-  annotations:
-    osInfo: ubuntu,20.04,amd64
-  labels:
-    tanzuKubernetesRelease: v1.22.5---vmware.1-tkg.2-zshippable
-    tkg.tanzu.vmware.com/cluster-name: wcc2
-  name: wcc2
-  namespace: default
-spec:
-  clusterNetwork:
-    pods:
-      cidrBlocks:
-      - 100.96.0.0/11
-    services:
-      cidrBlocks:
-      - 100.64.0.0/13
-  topology:
-    class: tkg-aws-default
-    controlPlane:
-      replicas: 1
-    variables:
-    - name: CLUSTER_PLAN
-      value: devcc
-    - name: AWS_AMI_ID
-      value: "ami-0b12ea388b0c61c8f"
-    - name: AWS_REGION
-      value: us-west-2
-    - name: AWS_NODE_AZ
-      value: us-west-2a
-    - name: AWS_VPC_ID
-      value: ""
-    - name: AWS_PRIVATE_SUBNET_ID
-      value: ""
-    - name: AWS_PUBLIC_SUBNET_ID
-      value: ""
-    - name: AWS_VPC_CIDR
-      value: 10.0.0.0/16
-    - name: AWS_PRIVATE_NODE_CIDR
-      value: 10.0.16.0/20
-    - name: AWS_PUBLIC_NODE_CIDR
-      value: 10.0.0.0/20
-    - name: AWS_SECURITY_GROUP_APISERVER_LB
-      value: ""
-    - name: AWS_SECURITY_GROUP_BASTION
-      value: ""
-    - name: AWS_SECURITY_GROUP_CONTROLPLANE
-      value: ""
-    - name: AWS_SECURITY_GROUP_LB
-      value: ""
-    - name: AWS_SECURITY_GROUP_NODE
-      value: ""
-    - name: AWS_IDENTITY_REF_KIND
-      value: ""
-    - name: AWS_IDENTITY_REF_NAME
-      value: ""
-    - name: AWS_CONTROL_PLANE_OS_DISK_SIZE_GIB
-      value: 80
-    - name: AWS_NODE_OS_DISK_SIZE_GIB
-      value: 80
-    - name: CONTROL_PLANE_MACHINE_TYPE
-      value: m3.xlarge
-    - name: NODE_MACHINE_TYPE
-      value: m3.xlarge
-    - name: AWS_SSH_KEY_NAME
-      value: default
-    - name: BASTION_HOST_ENABLED
-      value: false
-    - name: AWS_LOAD_BALANCER_SCHEME_INTERNAL
-      value: false
-    - name: TKG_CUSTOM_IMAGE_REPOSITORY
-      value: ""
-    - name: TKG_CUSTOM_IMAGE_REPOSITORY_HOSTNAME
-      value: projects-stg.registry.vmware.com
-    - name: TKG_CUSTOM_IMAGE_REPOSITORY_SKIP_TLS_VERIFY
-      value: true
-    - name: TKG_CUSTOM_IMAGE_REPOSITORY_CA_CERTIFICATE
-      value: ""
-    - name: TKG_PROXY_CA_CERT
-      value: ""
-    - name: ENABLE_AUDIT_LOGGING
-      value: ""
-    version: v1.22.5+vmware.1
-    workers:
-      machineDeployments:
-      - class: tkg-worker
-        failureDomain: us-west-2a
-        name: md-0
-        replicas: 1
----
diff --git a/pkg/v1/tkg/fakes/config/ccluster2_multipleObjects.yaml b/pkg/v1/tkg/fakes/config/ccluster2_multipleObjects.yaml
deleted file mode 100644
index 47b8aa7a72..0000000000
--- a/pkg/v1/tkg/fakes/config/ccluster2_multipleObjects.yaml
+++ /dev/null
@@ -1,127 +0,0 @@
-apiVersion: infrastructure.cluster.x-k8s.io/v1beta1
-kind: AWSMachineTemplate
-metadata:
-  name: tkg-aws-controlplane-template
-  namespace: default
-spec:
-  template:
-    spec:
-      ami:
-        id: ${AWS_AMI_ID}
-      iamInstanceProfile: control-plane.tkg.cloud.vmware.com
-      instanceType: ${CONTROL_PLANE_MACHINE_TYPE}
-      rootVolume:
-        size: 80
-      sshKeyName: ${AWS_SSH_KEY_NAME}
----
-apiVersion: cluster.x-k8s.io/v1beta1
-kind: Cluster
-metadata:
-  annotations:
-    osInfo: ubuntu,20.04,amd64
-  labels:
-    tanzuKubernetesRelease: v1.22.5---vmware.1-tkg.2-zshippable
-    tkg.tanzu.vmware.com/cluster-name: wcc11
-  name: wcc11
-  namespace: default
-spec:
-  clusterNetwork:
-    pods:
-      cidrBlocks:
-      - 100.96.0.0/11
-    services:
-      cidrBlocks:
-      - 100.64.0.0/13
-  topology:
-    class: null
-    controlPlane:
-      replicas: 1
-    variables:
-    - name: CLUSTER_NAME
-      value: wcc11
-    - name: CLUSTER_PLAN
-      value: devcc
-    - name: AWS_REGION
-      value: us-west-2
-    - name: AWS_NODE_AZ
-      value: us-west-2a
-    - name: AWS_VPC_ID
-      value: ""
-    - name: AWS_PRIVATE_SUBNET_ID
-      value: ""
-    - name: AWS_PUBLIC_SUBNET_ID
-      value: ""
-    - name: AWS_VPC_CIDR
-      value: 10.0.0.0/16
-    - name: AWS_PRIVATE_NODE_CIDR
-      value: 10.0.16.0/20
-    - name: AWS_PUBLIC_NODE_CIDR
-      value: 10.0.0.0/20
-    - name: AWS_SECURITY_GROUP_APISERVER_LB
-      value: ""
-    - name: AWS_SECURITY_GROUP_BASTION
-      value: ""
-    - name: AWS_SECURITY_GROUP_CONTROLPLANE
-      value: ""
-    - name: AWS_SECURITY_GROUP_LB
-      value: ""
-    - name: AWS_SECURITY_GROUP_NODE
-      value: ""
-    - name: AWS_IDENTITY_REF_KIND
-      value: ""
-    - name: AWS_IDENTITY_REF_NAME
-      value: ""
-    - name: AWS_CONTROL_PLANE_OS_DISK_SIZE_GIB
-      value: 80
-    - name: AWS_NODE_OS_DISK_SIZE_GIB
-      value: 80
-    - name: CONTROL_PLANE_MACHINE_TYPE
-      value: m3.xlarge
-    - name: NODE_MACHINE_TYPE
-      value: m3.xlarge
-    - name: AWS_SSH_KEY_NAME
-      value: default
-    - name: BASTION_HOST_ENABLED
-      value: false
-    - name: AWS_LOAD_BALANCER_SCHEME_INTERNAL
-      value: false
-    - name: TKG_CUSTOM_IMAGE_REPOSITORY
-      value: ""
-    - name: TKG_CUSTOM_IMAGE_REPOSITORY_HOSTNAME
-      value: projects-stg.registry.vmware.com
-    - name: TKG_CUSTOM_IMAGE_REPOSITORY_SKIP_TLS_VERIFY
-      value: false
-    - name: TKG_CUSTOM_IMAGE_REPOSITORY_CA_CERTIFICATE
-      value: ""
-    - name: TKG_PROXY_CA_CERT
-      value: ""
-    - name: ENABLE_AUDIT_LOGGING
-      value: ""
-    version: v1.22.5+vmware.1
-    workers:
-      machineDeployments:
-      - class: tkg-worker
-        failureDomain: us-west-2a
-        name: md-0
-        replicas: 1
----
-apiVersion: infrastructure.cluster.x-k8s.io/v1beta1
-kind: AWSClusterTemplate
-metadata:
-  name: aws-cluster-template
-  namespace: default
-spec:
-  template:
-    spec:
-      bastion:
-        enabled: true
-      network:
-        subnets:
-        - availabilityZone: ${AWS_NODE_AZ}
-          cidrBlock: ${AWS_PRIVATE_NODE_CIDR}
-          id: ${AWS_PRIVATE_SUBNET_ID}
-        vpc:
-          cidrBlock: ${AWS_VPC_CIDR}
-          id: ${AWS_VPC_ID}
-      region: ${AWS_REGION}
-      sshKeyName: ${AWS_SSH_KEY_NAME}
diff --git a/pkg/v1/tkg/fakes/config/cluster1_clusterOnly.yaml b/pkg/v1/tkg/fakes/config/cluster1_clusterOnly.yaml
new file mode 100644
index 0000000000..196919f534
--- /dev/null
+++ b/pkg/v1/tkg/fakes/config/cluster1_clusterOnly.yaml
@@ -0,0 +1,92 @@
+apiVersion: cluster.x-k8s.io/v1beta1
+kind: Cluster
+metadata:
+  annotations:
+    osInfo: ubuntu,20.04,amd64
+  labels:
+    tanzuKubernetesRelease: v1.22.5---vmware.1-tkg.2-zshippable
+    tkg.tanzu.vmware.com/cluster-name: wcc2
+  name: wcc2
+  namespace: default
+spec:
+  clusterNetwork:
+    pods:
+      cidrBlocks:
+        - 100.96.0.0/11
+    services:
+      cidrBlocks:
+        - 100.64.0.0/13
+  topology:
+    class: tkg-aws-default
+    controlPlane:
+      replicas: 1
+    variables:
+      - name: CLUSTER_PLAN
+        value: devcc
+      - name: AWS_AMI_ID
+        value: "ami-0b12ea388b0c61c8f"
+      - name: AWS_REGION
+        value: us-west-2
+      - name: AWS_NODE_AZ
+        value: us-west-2a
+      - name: AWS_VPC_ID
+        value: ""
+      - name: AWS_PRIVATE_SUBNET_ID
+        value: ""
+      - name: AWS_PUBLIC_SUBNET_ID
+        value: ""
+      - name: AWS_VPC_CIDR
+        value: 10.0.0.0/16
+      - name: AWS_PRIVATE_NODE_CIDR
+        value: 10.0.16.0/20
+      - name: AWS_PUBLIC_NODE_CIDR
+        value: 10.0.0.0/20
+      - name: AWS_SECURITY_GROUP_APISERVER_LB
+        value: ""
+      - name: AWS_SECURITY_GROUP_BASTION
+        value: ""
+      - name: AWS_SECURITY_GROUP_CONTROLPLANE
+        value: ""
+      - name: AWS_SECURITY_GROUP_LB
+        value: ""
+      - name: AWS_SECURITY_GROUP_NODE
+        value: ""
+      - name: AWS_IDENTITY_REF_KIND
+        value: ""
+      - name: AWS_IDENTITY_REF_NAME
+        value: ""
+      - name: AWS_CONTROL_PLANE_OS_DISK_SIZE_GIB
+        value: 80
+      - name: AWS_NODE_OS_DISK_SIZE_GIB
+        value: 80
+      - name: CONTROL_PLANE_MACHINE_TYPE
+        value: m3.xlarge
+      - name: NODE_MACHINE_TYPE
+        value: m3.xlarge
+      - name: AWS_SSH_KEY_NAME
+        value: default
+      - name: BASTION_HOST_ENABLED
+        value: false
+      - name: AWS_LOAD_BALANCER_SCHEME_INTERNAL
+        value: false
+      - name: TKG_CUSTOM_IMAGE_REPOSITORY
+        value: ""
+      - name: TKG_CUSTOM_IMAGE_REPOSITORY_HOSTNAME
+        value: projects-stg.registry.vmware.com
+      - name: TKG_CUSTOM_IMAGE_REPOSITORY_SKIP_TLS_VERIFY
+        value: true
+      - name: TKG_CUSTOM_IMAGE_REPOSITORY_CA_CERTIFICATE
+        value: ""
+      - name: TKG_PROXY_CA_CERT
+        value: ""
+      - name: ENABLE_AUDIT_LOGGING
+        value: ""
+    version: v1.22.5+vmware.1
+    workers:
+      machineDeployments:
+        - class: tkg-worker
+          failureDomain: us-west-2a
+          name: md-0
+          replicas: 1
+---
+
diff --git a/pkg/v1/tkg/fakes/config/ccluster1_config.yaml b/pkg/v1/tkg/fakes/config/cluster1_config.yaml
similarity index 100%
rename from pkg/v1/tkg/fakes/config/ccluster1_config.yaml
rename to pkg/v1/tkg/fakes/config/cluster1_config.yaml
diff --git a/pkg/v1/tkg/fakes/config/cluster_aws.yaml b/pkg/v1/tkg/fakes/config/cluster_aws.yaml
new file mode 100644
index 0000000000..cb88448739
--- /dev/null
+++ b/pkg/v1/tkg/fakes/config/cluster_aws.yaml
@@ -0,0 +1,154 @@
+apiVersion: cluster.x-k8s.io/v1beta1
+kind: Cluster
+metadata:
+  annotations:
+    osInfo: ubuntu,20.04,amd64
+    run.tanzu.vmware.com/resolve-tkr: ""
+  labels:
+    tkg.tanzu.vmware.com/cluster-name: aws-workload-cluster1
+  name: aws-workload-cluster1 # // CLUSTER_NAME
+  namespace: default # NAMESPACE
+spec:
+  clusterNetwork:
+    pods:
+      cidrBlocks:
+        - 2002::1234:abcd:ffff:c0a8:101/64 # CLUSTER_CIDR
+        - 100.96.0.0/11 # CLUSTER_CIDR
+    services:
+      cidrBlocks:
+        - 2002::1234:abcd:ffff:c0a8:101/64
+        - 100.64.0.0/18 # SERVICE_CIDR
+  topology:
+    class: tkg-aws-default # CLUSTER_CLASS
+    controlPlane:
+      metadata:
+        annotations:
+          run.tanzu.vmware.com/resolve-os-image: ami-region=us-east-1,os-name=ubuntu
+      replicas: 1 # CONTROL_PLANE_MACHINE_COUNT
+    variables:
+      - name: network
+        value:
+          ipv6Primary: true #TKG_IP_FAMILY (if true expect TKG_IP_FAMILY="ipv6,ipv4")
+          proxy: #TKG_HTTP_PROXY_ENABLED (under this if any value is not null then set TKG_HTTP_PROXY_ENABLED)
+            httpProxy: http://10.0.200.100 #TKG_HTTP_PROXY
+            httpsProxy: http://10.0.200.100 #TKG_HTTPS_PROXY
+            noProxy: #TKG_NO_PROXY
+              - 127.0.0.1
+              - 100.64.0.0/18
+              - 10.0.0.0/16
+              - 169.254.0.0/16
+              - .svc.cluster.local
+              - .svc
+              - localhost
+          subnets:
+            - az: us-east-1a #AWS_NODE_AZ
+              private:
+                cidr: 10.0.0.0/24 #AWS_PRIVATE_NODE_CIDR
+                id: idValue #AWS_PRIVATE_SUBNET_ID
+              public:
+                cidr: 10.1.1.0/24 #AWS_PUBLIC_NODE_CIDR
+                id: idValue #AWS_PUBLIC_SUBNET_ID
+            - az: us-west-1a # AWS_NODE_AZ_1
+              private:
+                cidr: 10.0.2.0/24 #AWS_PRIVATE_NODE_CIDR_1
+                id: idValue #AWS_PRIVATE_SUBNET_ID_1
+              public:
+                cidr: 10.0.3.0/24 #AWS_PUBLIC_NODE_CIDR_1
+                id: idValue #AWS_PUBLIC_SUBNET_ID_1
+            - az: us-east-1b #AWS_NODE_AZ_2
+              private:
+                cidr: 10.0.4.0/24 #AWS_PRIVATE_NODE_CIDR_2
+                id: idValuePrivate2 #AWS_PRIVATE_SUBNET_ID_2
+              public:
+                cidr: 10.0.5.0/24 #AWS_PUBLIC_NODE_CIDR_2
+                id: idValue #AWS_PUBLIC_SUBNET_ID_2
+          vpc:
+            cidr: 10.0.0.0/16 # AWS_VPC_CIDR
+            existingID: vpcID11 # AWS_VPC_ID
+          securityGroupOverrides:
+            bastion: bationValue # AWS_SECURITY_GROUP_BASTION
+            apiServerLB: apiserverlb # AWS_SECURITY_GROUP_APISERVER_LB
+            lb: lbvalue # AWS_SECURITY_GROUP_LB
+            controlPlane: controlplaneValue # AWS_SECURITY_GROUP_CONTROLPLANE
+            node: securitygroupNode # AWS_SECURITY_GROUP_NODE
+      - name: imageRepository
+        value:
+          host: imageRepositoryHost #TKG_CUSTOM_IMAGE_REPOSITORY
+          tlsCertificateValidation: true #TKG_CUSTOM_IMAGE_REPOSITORY_SKIP_TLS_VERIFY
+      - name: clusterRole #TKG_CLUSTER_ROLE
+        value: workload
+      - name: auditLogging
+        value:
+          enabled: true #ENABLE_AUDIT_LOGGING
+      - name: trust
+        value:
+          - name: proxy
+            data: "trust.proxy.val" #TKG_PROXY_CA_CERT
+          - name: imageRepository
+            data: "trust.imageRepository.val" #TKG_CUSTOM_IMAGE_REPOSITORY_CA_CERTIFICATE
+      - name: apiServerPort
+        value: 9090 #CLUSTER_API_SERVER_PORT
+      - name: bastion
+        value:
+          enabled: true #BASTION_HOST_ENABLED
+      - name: identityRef
+        value:
+          name: identityrefname #AWS_IDENTITY_REF_NAME
+          kind: AWSClusterRoleIdentity #AWS_IDENTITY_REF_KIND
+      - name: worker
+        value:
+          instanceType: m5.large #NODE_MACHINE_TYPE
+          rootVolume:
+            sizeGiB: 80 # AWS_NODE_OS_DISK_SIZE_GIB
+      - name: controlPlane
+        value:
+          instanceType: t3.large #CONTROL_PLANE_MACHINE_TYPE
+          rootVolume:
+            sizeGiB: 80 #AWS_CONTROL_PLANE_OS_DISK_SIZE_GIB
+      - name: TKR_DATA
+        value:
+          v1.23.5+vmware.1:
+            kubernetesSpec:
+              coredns:
+                imageTag: v1.8.6_vmware.5
+              etcd:
+                imageTag: v3.5.2_vmware.4
+              imageRepository: projects.registry.vmware.com/tkg
+              version: v1.23.5+vmware.1
+            labels:
+              os-arch: amd64
+              os-name: ubuntu
+              os-type: linux
+            osImageRef:
+              id: dummy-ami-id
+              region: dummy-region
+    version: v1.23.5+vmware.1 # KUBERNETES_VERSION
+    workers:
+      machineDeployments:
+        - class: tkg-worker
+          failureDomain: us-east-1a
+          metadata:
+            annotations:
+              run.tanzu.vmware.com/resolve-os-image: ami-region=us-east-1,os-name=ubuntu
+          name: md-0
+          replicas: 1 #WORKER_MACHINE_COUNT_0
+        - class: tkg-worker
+          failureDomain: us-east-1b
+          name: md-1
+          replicas: 2 #WORKER_MACHINE_COUNT_1
+          variables:
+            overrides:
+              - name: worker
+                value:
+                  instanceType: worker1 # NODE_MACHINE_TYPE_1
+        - class: tkg-worker
+          failureDomain: us-east-1c
+          name: md-2
+          replicas: 3 #WORKER_MACHINE_COUNT_2
+          variables:
+            overrides:
+              - name: worker
+                value:
+                  instanceType: worker2 # NODE_MACHINE_TYPE_2
+---
+
diff --git a/pkg/v1/tkg/fakes/config/cluster_aws_emptyClass.yaml b/pkg/v1/tkg/fakes/config/cluster_aws_emptyClass.yaml
new file mode 100644
index 0000000000..39e473ad7b
--- /dev/null
+++ b/pkg/v1/tkg/fakes/config/cluster_aws_emptyClass.yaml
@@ -0,0 +1,8 @@
+apiVersion: cluster.x-k8s.io/v1beta1
+kind: Cluster
+metadata:
+  name: aws-workload-cluster1
+  namespace: namespace-test1
+spec:
+  topology:
+    class:
diff --git a/pkg/v1/tkg/fakes/config/cluster_aws_incorrectClass.yaml b/pkg/v1/tkg/fakes/config/cluster_aws_incorrectClass.yaml
new file mode 100644
index 0000000000..7e70423d8d
--- /dev/null
+++ b/pkg/v1/tkg/fakes/config/cluster_aws_incorrectClass.yaml
@@ -0,0 +1,152 @@
+apiVersion: cluster.x-k8s.io/v1beta1
+kind: Cluster
+metadata:
+  annotations:
+    osInfo: ubuntu,20.04,amd64
+    run.tanzu.vmware.com/resolve-tkr: ""
+  labels:
+    tkg.tanzu.vmware.com/cluster-name: testcluster
+  name: testcluster # // CLUSTER_NAME
+  namespace: default # NAMESPACE
+spec:
+  clusterNetwork:
+    pods:
+      cidrBlocks:
+        - 100.96.0.0/11 # CLUSTER_CIDR
+    services:
+      cidrBlocks:
+        - 100.64.0.0/18 # SERVICE_CIDR
+  topology:
+    class: tkg-UNKNOWN-default # CLUSTER_CLASS
+    controlPlane:
+      metadata:
+        annotations:
+          run.tanzu.vmware.com/resolve-os-image: ami-region=us-east-1,os-name=ubuntu
+      replicas: 1 # CONTROL_PLANE_MACHINE_COUNT
+    variables:
+      - name: network
+        value:
+          ipv6Primary: true #TKG_IP_FAMILY (if true set TKG_IP_FAMILY="ipv6,ipv4")
+          proxy: #TKG_HTTP_PROXY (under this if any value is not null then set TKG_HTTP_PROXY)
+            httpProxy: http://10.0.200.100 #TKG_HTTP_PROXY
+            httpsProxy: http://10.0.200.100 #TKG_HTTPS_PROXY
+            noProxy: #TKG_NO_PROXY
+              - 127.0.0.1
+              - 100.64.0.0/18
+              - 10.0.0.0/16
+              - 169.254.0.0/16
+              - .svc.cluster.local
+              - .svc
+              - localhost
+          subnets:
+            - az: us-east-1a #AWS_NODE_AZ
+              private:
+                cidr: 10.0.0.0/24 #AWS_PRIVATE_NODE_CIDR
+                id: idValue #AWS_PRIVATE_SUBNET_ID
+              public:
+                cidr: 10.0.1.0/24 #AWS_PUBLIC_NODE_CIDR
+                id: idValue #AWS_PUBLIC_SUBNET_ID
+            - az: us-west-1a # AWS_NODE_AZ_1
+              private:
+                cidr: 10.0.2.0/24 #AWS_PRIVATE_NODE_CIDR_1
+                id: idValue #AWS_PRIVATE_SUBNET_ID_1
+              public:
+                cidr: 10.0.3.0/24 #AWS_PUBLIC_NODE_CIDR_1
+                id: idValue #AWS_PUBLIC_SUBNET_ID_1
+            - az: us-east-1b #AWS_NODE_AZ_2
+              private:
+                cidr: 10.0.4.0/24 #AWS_PRIVATE_NODE_CIDR_2
+                id: idValue #AWS_PRIVATE_SUBNET_ID_2
+              public:
+                cidr: 10.0.5.0/24 #AWS_PUBLIC_NODE_CIDR_2
+                id: idValue #AWS_PUBLIC_SUBNET_ID_2
+          vpc:
+            cidr: 10.0.0.0/16 # AWS_VPC_CIDR
+            existingID: "vpcID" # AWS_VPC_ID
+          securityGroupOverrides:
+            bastion: bationValue # AWS_SECURITY_GROUP_BASTION
+            apiServerLB: apiserverlb # AWS_SECURITY_GROUP_APISERVER_LB
+            lb: lbvalue # AWS_SECURITY_GROUP_LB
+            controlPlane: controlplaneValue # AWS_SECURITY_GROUP_CONTROLPLANE
+            node: securitygroupNode # AWS_SECURITY_GROUP_NODE
+      - name: imageRepository
+        value:
+          host: imageRepositoryHost #TKG_CUSTOM_IMAGE_REPOSITORY
+          tlsCertificateValidation: true #TKG_CUSTOM_IMAGE_REPOSITORY_SKIP_TLS_VERIFY
+      - name: clusterRole #TKG_CLUSTER_ROLE
+        value: workload
+      - name: auditLogging
+        value:
+          enabled: true #ENABLE_AUDIT_LOGGING
+      - name: trust
+        value:
+          - name: proxy
+            data: "trust.proxy.val" #TKG_PROXY_CA_CERT
+          - name: imageRepository
+            data: "trust.imageRepository.val" #TKG_CUSTOM_IMAGE_REPOSITORY_CA_CERTIFICATE
+      - name: apiServerPort
+        value: 9090 #CLUSTER_API_SERVER_PORT
+      - name: bastion
+        value:
+          enabled: true #BASTION_HOST_ENABLED
+      - name: identityRef
+        value:
+          name: identityrefname #AWS_IDENTITY_REF_NAME
+          kind: AWSClusterRoleIdentity #AWS_IDENTITY_REF_KIND
+      - name: worker
+        value:
+          instanceType: m5.large #NODE_MACHINE_TYPE
+          rootVolume:
+            sizeGiB: 80 # AWS_NODE_OS_DISK_SIZE_GIB
+      - name: controlPlane
+        value:
+          instanceType: t3.large #CONTROL_PLANE_MACHINE_TYPE
+          rootVolume:
+            sizeGiB: 80 #AWS_CONTROL_PLANE_OS_DISK_SIZE_GIB
+      - name: TKR_DATA
+        value:
+          v1.23.5+vmware.1:
+            kubernetesSpec:
+              coredns:
+                imageTag: v1.8.6_vmware.5
+              etcd:
+                imageTag: v3.5.2_vmware.4
+              imageRepository: projects.registry.vmware.com/tkg
+              version: v1.23.5+vmware.1
+            labels:
+              os-arch: amd64
+              os-name: ubuntu
+              os-type: linux
+            osImageRef:
+              id: dummy-ami-id
+              region: dummy-region
+    version: v1.23.5+vmware.1 # KUBERNETES_VERSION
+    workers:
+      machineDeployments:
+        - class: tkg-worker
+          failureDomain: us-east-1a
+          metadata:
+            annotations:
+              run.tanzu.vmware.com/resolve-os-image: ami-region=us-east-1,os-name=ubuntu
+          name: md-0
+          replicas: 1 #WORKER_MACHINE_COUNT_0
+        - class: tkg-worker
+          failureDomain: us-east-1b
+          name: md-1
+          replicas: 2 #WORKER_MACHINE_COUNT_1
+          variables:
+            overrides:
+              - name: worker
+                value:
+                  instanceType: worker1 # NODE_MACHINE_TYPE_1
+        - class: tkg-worker
+          failureDomain: us-east-1c
+          name: md-2
+          replicas: 3 #WORKER_MACHINE_COUNT_2
+          variables:
+            overrides:
+              - name: worker
+                value:
+                  instanceType: worker2 # NODE_MACHINE_TYPE_2
+---
+
diff --git a/pkg/v1/tkg/fakes/config/cluster_aws_multipleObjects.yaml b/pkg/v1/tkg/fakes/config/cluster_aws_multipleObjects.yaml
new file mode 100644
index 0000000000..6a6f24d7d3
--- /dev/null
+++ b/pkg/v1/tkg/fakes/config/cluster_aws_multipleObjects.yaml
@@ -0,0 +1,188 @@
+apiVersion: infrastructure.cluster.x-k8s.io/v1beta1
+kind: AWSMachineTemplate
+metadata:
+  name: tkg-aws-controlplane-template
+  namespace: aws-workload-cluster1
+spec:
+  template:
+    spec:
+      ami:
+        id:
+      iamInstanceProfile: control-plane.tkg.cloud.vmware.com
+      instanceType:
+      rootVolume:
+        size: 80
+      sshKeyName:
+---
+apiVersion: cluster.x-k8s.io/v1beta1
+kind: Cluster
+metadata:
+  annotations:
+    osInfo: ubuntu,20.04,amd64
+    run.tanzu.vmware.com/resolve-tkr: ""
+  labels:
+    tkg.tanzu.vmware.com/cluster-name: aws-workload-cluster1
+  name: aws-workload-cluster1 # // CLUSTER_NAME
+  namespace: default # NAMESPACE
+spec:
+  clusterNetwork:
+    pods:
+      cidrBlocks:
+        - 100.96.0.0/11 # CLUSTER_CIDR
+        - 100.96.0.0/16 # CLUSTER_CIDR
+    services:
+      cidrBlocks:
+        - 100.64.0.0/18 # SERVICE_CIDR
+  topology:
+    class: tkg-aws-default # CLUSTER_CLASS
+    controlPlane:
+      metadata:
+        annotations:
+          run.tanzu.vmware.com/resolve-os-image: ami-region=us-east-1,os-name=ubuntu
+      replicas: 1 # CONTROL_PLANE_MACHINE_COUNT
+    variables:
+      - name: network
+        value:
+          ipv6Primary: false #TKG_IP_FAMILY
+          proxy: #TKG_HTTP_PROXY_ENABLED (under this if any value is not null then set TKG_HTTP_PROXY_ENABLED)
+            httpProxy: http://10.0.200.100 #TKG_HTTP_PROXY
+            httpsProxy: http://10.0.200.100 #TKG_HTTPS_PROXY
+            noProxy: #TKG_NO_PROXY
+              - 127.0.0.1
+              - 100.64.0.0/18
+              - 10.0.0.0/16
+              - 169.254.0.0/16
+              - .svc.cluster.local
+              - .svc
+              - localhost
+          subnets:
+            - az: us-east-1a #AWS_NODE_AZ
+              private:
+                cidr: 10.0.0.0/24 #AWS_PRIVATE_NODE_CIDR
+                id: idValue #AWS_PRIVATE_SUBNET_ID
+              public:
+                cidr: 10.1.1.0/24 #AWS_PUBLIC_NODE_CIDR
+                id: idValue #AWS_PUBLIC_SUBNET_ID
+            - az: us-west-1a # AWS_NODE_AZ_1
+              private:
+                cidr: 10.0.2.0/24 #AWS_PRIVATE_NODE_CIDR_1
+                id: idValue #AWS_PRIVATE_SUBNET_ID_1
+              public:
+                cidr: 10.0.3.0/24 #AWS_PUBLIC_NODE_CIDR_1
+                id: idValue #AWS_PUBLIC_SUBNET_ID_1
+            - az: us-east-1b #AWS_NODE_AZ_2
+              private:
+                cidr: 10.0.4.0/24 #AWS_PRIVATE_NODE_CIDR_2
+                id: idValuePrivate2 #AWS_PRIVATE_SUBNET_ID_2
+              public:
+                cidr: 10.0.5.0/24 #AWS_PUBLIC_NODE_CIDR_2
+                id: idValue #AWS_PUBLIC_SUBNET_ID_2
+          vpc:
+            cidr: 10.0.0.0/16 # AWS_VPC_CIDR
+            existingID: "vpcID" # AWS_VPC_ID
+          securityGroupOverrides:
+            bastion: bationValue # AWS_SECURITY_GROUP_BASTION
+            apiServerLB: apiserverlb # AWS_SECURITY_GROUP_APISERVER_LB
+            lb: lbvalue # AWS_SECURITY_GROUP_LB
+            controlPlane: controlplaneValue # AWS_SECURITY_GROUP_CONTROLPLANE
+            node: securitygroupNode # AWS_SECURITY_GROUP_NODE
+      - name: imageRepository
+        value:
+          host: imageRepositoryHost #TKG_CUSTOM_IMAGE_REPOSITORY
+          tlsCertificateValidation: true #TKG_CUSTOM_IMAGE_REPOSITORY_SKIP_TLS_VERIFY
+      - name: clusterRole #TKG_CLUSTER_ROLE
+        value: workload
+      - name: auditLogging
+        value:
+          enabled: true #ENABLE_AUDIT_LOGGING
+      - name: trust
+        value:
+          - name: proxy
+            data: "trust.proxy.val" #TKG_PROXY_CA_CERT
+          - name: imageRepository
+            data: "trust.imageRepository.val" #TKG_CUSTOM_IMAGE_REPOSITORY_CA_CERTIFICATE
+      - name: apiServerPort
+        value: 9090 #CLUSTER_API_SERVER_PORT
+      - name: bastion
+        value:
+          enabled: true #BASTION_HOST_ENABLED
+      - name: identityRef
+        value:
+          name: identityrefname #AWS_IDENTITY_REF_NAME
+          kind: AWSClusterRoleIdentity #AWS_IDENTITY_REF_KIND
+      - name: worker
+        value:
+          instanceType: m5.large #NODE_MACHINE_TYPE
+          rootVolume:
+            sizeGiB: 80 # AWS_NODE_OS_DISK_SIZE_GIB
+      - name: controlPlane
+        value:
+          instanceType: t3.large #CONTROL_PLANE_MACHINE_TYPE
+          rootVolume:
+            sizeGiB: 80 #AWS_CONTROL_PLANE_OS_DISK_SIZE_GIB
+      - name: TKR_DATA
+        value:
+          v1.23.5+vmware.1:
+            kubernetesSpec:
+              coredns:
+                imageTag: v1.8.6_vmware.5
+              etcd:
+                imageTag: v3.5.2_vmware.4
+              imageRepository: projects.registry.vmware.com/tkg
+              version: v1.23.5+vmware.1
+            labels:
+              os-arch: amd64
+              os-name: ubuntu
+              os-type: linux
+            osImageRef:
+              id: dummy-ami-id
+              region: dummy-region
+    version: v1.23.5+vmware.1 # KUBERNETES_VERSION
+    workers:
+      machineDeployments:
+        - class: tkg-worker
+          failureDomain: us-east-1a
+          metadata:
+            annotations:
+              run.tanzu.vmware.com/resolve-os-image: ami-region=us-east-1,os-name=ubuntu
+          name: md-0
+          replicas: 1 #WORKER_MACHINE_COUNT_0
+        - class: tkg-worker
+          failureDomain: us-east-1b
+          name: md-1
+          replicas: 2 #WORKER_MACHINE_COUNT_1
+          variables:
+            overrides:
+              - name: worker
+                value:
+                  instanceType: worker1 # NODE_MACHINE_TYPE_1
+        - class: tkg-worker
+          failureDomain: us-east-1c
+          name: md-2
+          replicas: 3 #WORKER_MACHINE_COUNT_2
+          variables:
+            overrides:
+              - name: worker
+                value:
+                  instanceType: worker2 # NODE_MACHINE_TYPE_2
+---
+apiVersion: infrastructure.cluster.x-k8s.io/v1beta1
+kind: AWSClusterTemplate
+metadata:
+  name: aws-cluster-template
+  namespace: default
+spec:
+  template:
+    spec:
+      bastion:
+        enabled: true
+      network:
+        subnets:
+          - availabilityZone:
+            cidrBlock:
+            id:
+        vpc:
+          cidrBlock:
+          id:
+      region:
+      sshKeyName:
diff --git a/pkg/v1/tkg/fakes/config/cluster_azure.yaml b/pkg/v1/tkg/fakes/config/cluster_azure.yaml
new file mode 100644
index 0000000000..743915cb98
--- /dev/null
+++ b/pkg/v1/tkg/fakes/config/cluster_azure.yaml
@@ -0,0 +1,167 @@
+apiVersion: cluster.x-k8s.io/v1beta1
+kind: Cluster
+metadata:
+  annotations:
+    osInfo: ubuntu,18.04,amd64
+  labels:
+    tanzuKubernetesRelease: v0.0.0---marketplace-image
+    tkg.tanzu.vmware.com/cluster-name: testcluster
+  name: azure-workload-cluster1
+  namespace: namespace-test1
+spec:
+  clusterNetwork:
+    pods:
+      cidrBlocks: #CLUSTER_CIDR
+        - 10.10.10.10/18
+    services:
+      cidrBlocks: #SERVICE_CIDR
+        - 10.10.10.10/16
+  topology:
+    class: tkg-azure-default #CLUSTER_CLASS
+    controlPlane:
+      replicas: 5 #CONTROL_PLANE_MACHINE_COUNT
+    variables:
+      - name: network
+        value:
+          ipv6Primary: false #TKG_IP_FAMILY (if true expect TKG_IP_FAMILY="ipv6,ipv4")
+          proxy: #TKG_HTTP_PROXY_ENABLED (under this if any value is not null then set TKG_HTTP_PROXY_ENABLED)
+            httpProxy: http://10.0.200.100 #TKG_HTTP_PROXY
+            httpsProxy: http://10.0.200.100 #TKG_HTTPS_PROXY
+            noProxy: #TKG_NO_PROXY
+              - 127.0.0.1
+              - 100.64.0.0/18
+              - 10.0.0.0/16
+              - 169.254.0.0/16
+              - .svc.cluster.local
+              - .svc
+              - localhost
+          vnet:
+            cidrBlocks: #AZURE_VNET_CIDR
+              - 10.0.0.0/8
+              - 10.0.0.0/16
+            name: azure-vnet-name #AZURE_VNET_NAME
+            resourceGroup: azure-vnet-resource-group #AZURE_VNET_RESOURCE_GROUP
+      - name: imageRepository
+        value:
+          host: imageRepositoryHost #TKG_CUSTOM_IMAGE_REPOSITORY
+          tlsCertificateValidation: true #TKG_CUSTOM_IMAGE_REPOSITORY_SKIP_TLS_VERIFY
+      - name: clusterRole #TKG_CLUSTER_ROLE
+        value: workload
+      - name: auditLogging
+        value:
+          enabled: false #ENABLE_AUDIT_LOGGING
+      - name: trust
+        value:
+          - name: proxy
+            data: trust.proxy.val #TKG_PROXY_CA_CERT
+          - name: imageRepository
+            data: trust.imageRepository.val #TKG_CUSTOM_IMAGE_REPOSITORY_CA_CERTIFICATE
+      - name: apiServerPort
+        value: 9090 #CLUSTER_API_SERVER_PORT
+      - name: location #AZURE_LOCATION
+        value: westus
+      - name: resourceGroup #AZURE_RESOURCE_GROUP
+        value: ""
+      - name: subscriptionID #AZURE_SUBSCRIPTION_ID
+        value: 6c2a2ce1-649f-9d9k-a19c-c729h3cf6126
+      - name: environment #AZURE_ENVIRONMENT
+        value: AzurePublicCloud
+      - name: sshPublicKey #AZURE_SSH_PUBLIC_KEY_B64
+        value: c3NoLXJzYSBB
+      - name: frontendPrivateIP #AZURE_FRONTEND_PRIVATE_IP
+        value: 22.22.22.22
+      - name: customTags #AZURE_CUSTOM_TAGS
+        value: azureCustomTagsValue
+      - name: acceleratedNetworking #AZURE_ENABLE_ACCELERATED_NETWORKING
+        value:
+          enabled: true
+      - name: privateCluster #AZURE_ENABLE_PRIVATE_CLUSTER
+        value:
+          enabled: false
+      - name: identityRef
+        value:
+          name: test-identity1 #AZURE_IDENTITY_NAME
+          namespace: test-ns1 #AZURE_IDENTITY_NAMESPACE
+      - name: controlPlane
+        value:
+          vmSize: i3.xlarge #AZURE_CONTROL_PLANE_MACHINE_TYPE
+          dataDisks:
+            - sizeGiB: 256 #AZURE_CONTROL_PLANE_DATA_DISK_SIZE_GIB
+          osDisk:
+            sizeGiB: 128 #AZURE_CONTROL_PLANE_OS_DISK_SIZE_GIB
+            storageAccountType: Premium_LRS #AZURE_CONTROL_PLANE_OS_DISK_STORAGE_ACCOUNT_TYPE
+          subnet:
+            name: subnetName #AZURE_CONTROL_PLANE_SUBNET_NAME
+            cidr: 10.0.0.0/24 #AZURE_CONTROL_PLANE_SUBNET_CIDR
+            securityGroup: SecurityGroup #AZURE_CONTROL_PLANE_SUBNET_SECURITY_GROUP
+          outboundLB:
+            enabled: true #AZURE_ENABLE_CONTROL_PLANE_OUTBOUND_LB
+            frontendIPCount: 3 #AZURE_CONTROL_PLANE_OUTBOUND_LB_FRONTEND_IP_COUNT
+      - name: worker
+        value:
+          vmSize: m5.xlarge #AZURE_NODE_MACHINE_TYPE
+          osDisk:
+            sizeGiB: 128 #AZURE_NODE_OS_DISK_SIZE_GIB
+            storageAccountType: Premium_LRS #AZURE_NODE_OS_DISK_STORAGE_ACCOUNT_TYPE
+          dataDisks:
+            - sizeGiB: 256 #AZURE_NODE_DATA_DISK_SIZE_GIB
+          subnet:
+            name: workerSubnetName #AZURE_NODE_SUBNET_NAME
+            cidr: 10.1.0.0/16 #AZURE_NODE_SUBNET_CIDR
+            securityGroup: SecurityGroup #AZURE_NODE_SUBNET_SECURITY_GROUP
+          outboundLB:
+            enabled: true #AZURE_ENABLE_NODE_OUTBOUND_LB
+            frontendIPCount: 1 #AZURE_NODE_OUTBOUND_LB_FRONTEND_IP_COUNT
+            idleTimeoutInMinutes: 8 #AZURE_NODE_OUTBOUND_LB_IDLE_TIMEOUT_IN_MINUTES
+
+      - name: TKR_DATA
+        value:
+          v1.23.5+vmware.1:
+            kubernetesSpec:
+              coredns:
+                imageTag: v1.8.6_vmware.5
+              etcd:
+                imageTag: v3.5.2_vmware.4
+              imageRepository: projects.registry.vmware.com/tkg
+              version: v1.23.5+vmware.1
+            labels:
+              os-arch: amd64
+              os-name: ubuntu
+              os-type: linux
+            osImageRef:
+              offer: dummy-offer
+              publisher: dummy-publisher
+              sku: dummy-sku
+              thirdPartyImage: dummy-third-party-image
+              version: dummy-version
+    version: v1.23.5+vmware.1 #KUBERNETES_VERSION
+
+    workers:
+      machineDeployments:
+        - class: tkg-worker
+          failureDomain: us-east-1a #AZURE_NODE_AZ
+          metadata:
+            annotations:
+              run.tanzu.vmware.com/resolve-os-image: ami-region=us-east-1,os-name=ubuntu
+          name: md-0
+          replicas: 1 #WORKER_MACHINE_COUNT_0
+        - class: tkg-worker
+          failureDomain: us-east-1b #AZURE_NODE_AZ_1
+          name: md-1
+          replicas: 2 #WORKER_MACHINE_COUNT_1
+          variables:
+            overrides:
+              - name: worker
+                value:
+                  vmSize: worker1 # NODE_MACHINE_TYPE_1
+        - class: tkg-worker
+          failureDomain: us-east-1c #AZURE_NODE_AZ_2
+          name: md-2
+          replicas: 3 #WORKER_MACHINE_COUNT_2
+          variables:
+            overrides:
+              - name: worker
+                value:
+                  vmSize: worker2 # NODE_MACHINE_TYPE_2
+---
+
diff --git a/pkg/v1/tkg/fakes/config/cluster_vsphere.yaml b/pkg/v1/tkg/fakes/config/cluster_vsphere.yaml
new file mode 100644
index 0000000000..00f9afc2e5
--- /dev/null
+++ b/pkg/v1/tkg/fakes/config/cluster_vsphere.yaml
@@ -0,0 +1,127 @@
+apiVersion: cluster.x-k8s.io/v1beta1
+kind: Cluster
+metadata:
+  annotations:
+    osInfo: ",,"
+  labels:
+    cluster-role.tkg.tanzu.vmware.com/management: ""
+    tanzuKubernetesRelease: v1.23.5---vmware.1-tkg.1-zshippable
+    tkg.tanzu.vmware.com/cluster-name: c1
+  name: vsphere-workload-cluster1 # CLUSTER_NAME
+  namespace: namespace-test1
+spec:
+  clusterNetwork:
+    pods:
+      cidrBlocks: # CLUSTER_CIDR
+        - 10.10.10.10/18
+    services:
+      cidrBlocks: # SERVICE_CIDR
+        - 100.64.0.0/18
+  topology:
+    class: tkg-vsphere-default # CLUSTER_CLASS
+    controlPlane:
+      replicas: 5 # CONTROL_PLANE_MACHINE_COUNT
+    variables:
+      - name: network
+        value:
+          ipv6Primary: false #TKG_IP_FAMILY (if true expect TKG_IP_FAMILY="ipv6,ipv4")
+          proxy: #TKG_HTTP_PROXY_ENABLED (under this if any value is not null then set TKG_HTTP_PROXY_ENABLED)
+            httpProxy: http://10.0.200.100 #TKG_HTTP_PROXY
+            httpsProxy: http://10.0.200.100 #TKG_HTTPS_PROXY
+            noProxy: #TKG_NO_PROXY
+              - 127.0.0.1
+              - 100.64.0.0/18
+              - 10.0.0.0/16
+              - 169.254.0.0/16
+              - .svc.cluster.local
+              - .svc
+              - localhost
+      - name: imageRepository
+        value:
+          host: imageRepositoryHost #TKG_CUSTOM_IMAGE_REPOSITORY
+          tlsCertificateValidation: true #TKG_CUSTOM_IMAGE_REPOSITORY_SKIP_TLS_VERIFY
+      - name: clusterRole #TKG_CLUSTER_ROLE
+        value: workload
+      - name: auditLogging
+        value:
+          enabled: false #ENABLE_AUDIT_LOGGING
+      - name: trust
+        value:
+          - name: proxy
+            data: LS0tLS= #TKG_PROXY_CA_CERT
+          - name: imageRepository
+            data: trust.imageRepository.val #TKG_CUSTOM_IMAGE_REPOSITORY_CA_CERTIFICATE
+      - name: apiServerPort
+        value: 443 #CLUSTER_API_SERVER_PORT
+      - name: apiServerEndpoint # VSPHERE_CONTROL_PLANE_ENDPOINT
+        value: http://10.0.200.101
+      - name: vipNetworkInterface # VIP_NETWORK_INTERFACE
+        value: networkinter
+      - name: aviAPIServerHAProvider # AVI_CONTROL_PLANE_HA_PROVIDER
+        value: true
+      - name: vcenter
+        value:
+          cloneMode: fullClone # VSPHERE_CLONE_MODE
+          network: TESTNETWORK # VSPHERE_NETWORK
+          datacenter: /dc0 # VSPHERE_DATACENTER
+          datastore: ds1 # VSPHERE_DATASTORE
+          folder: vm0 #  VSPHERE_FOLDER
+          resourcePool: /dc0/host/cluster0/Resources/rp0 # VSPHERE_RESOURCE_POOL
+          storagePolicyID: "" # VSPHERE_STORAGE_POLICY_ID
+          server: some.fqdn.com # VSPHERE_SERVER
+          tlsThumbprint: dummythumbprint # VSPHERE_TLS_THUMBPRINT
+          template: photon-3-v1.19.3+vmware.1 # VSPHERE_TEMPLATE
+      - name: user
+        value:
+          sshAuthorizedKeys: # VSPHERE_SSH_AUTHORIZED_KEY
+            - authkeyss11
+            - authkeyss22
+      - name: controlPlane
+        value:
+          machine:
+            diskGiB: 40 # VSPHERE_CONTROL_PLANE_DISK_GIB
+            memoryMiB: 8192 # VSPHERE_CONTROL_PLANE_MEM_MIB
+            numCPUs: 2 # VSPHERE_CONTROL_PLANE_NUM_CPUS
+          network:
+            nameservers: 100.64.0.0 # CONTROL_PLANE_NODE_NAMESERVERS
+      - name: worker
+        value:
+          count: 3 # WORKER_MACHINE_COUNT -- Removed
+          machine:
+            diskGiB: 40 # VSPHERE_WORKER_DISK_GIB
+            memoryMiB: 16384 # VSPHERE_WORKER_MEM_MIB
+            numCPUs: 4 # VSPHERE_WORKER_NUM_CPUS
+          network:
+            nameservers: 100.64.0.0 # WORKER_NODE_NAMESERVERS
+      - name: TKR_DATA
+        value:
+          v1.21.2:
+            kubernetesSpec:
+              coredns:
+                imageTag: v1.8.6_vmware.5
+              etcd:
+                imageTag: v3.5.2_vmware.4
+              imageRepository: projects.registry.vmware.com/tkg
+              kube-vip:
+                imageTag: dummy-kube-vip-image-tag
+              version: v1.21.2
+            labels:
+              os-arch: amd64
+              os-name: ubuntu
+              os-type: linux
+
+    version: v1.21.2
+    workers:
+      machineDeployments:
+        - class: tkg-worker
+          failureDomain: us-east-1a # VSPHERE_AZ_0
+          name: md-0
+          replicas: 1 #WORKER_MACHINE_COUNT
+        - class: tkg-worker
+          failureDomain: us-east-1b # VSPHERE_AZ_1
+          name: md-1
+          replicas: 2 # WORKER_MACHINE_COUNT_1
+        - class: tkg-worker
+          failureDomain: us-east-1c # VSPHERE_AZ_2
+          name: md-2
+          replicas: 3 # WORKER_MACHINE_COUNT_2
diff --git a/pkg/v1/tkg/managementcomponents/helper.go b/pkg/v1/tkg/managementcomponents/helper.go
index d9edea9dc9..90a0be7d8a 100644
--- a/pkg/v1/tkg/managementcomponents/helper.go
+++ b/pkg/v1/tkg/managementcomponents/helper.go
@@ -5,13 +5,17 @@
 package managementcomponents
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"time"
 
 	"gopkg.in/yaml.v3"
 
+	"github.com/pkg/errors"
+
 	"github.com/vmware-tanzu/tanzu-framework/pkg/v1/tkg/constants"
+	"github.com/vmware-tanzu/tanzu-framework/pkg/v1/tkg/tkgconfigbom"
 	"github.com/vmware-tanzu/tanzu-framework/pkg/v1/tkg/utils"
 )
 
@@ -21,10 +25,25 @@ const (
 )
 
 // GetTKGPackageConfigValuesFileFromUserConfig returns values file from user configuration
-func GetTKGPackageConfigValuesFileFromUserConfig(managementPackageVersion string, userProviderConfigValues map[string]string) (string, error) {
+func GetTKGPackageConfigValuesFileFromUserConfig(managementPackageVersion string, userProviderConfigValues map[string]interface{}, tkgBomConfig *tkgconfigbom.BOMConfiguration) (string, error) {
+	// TODO: Temporary hack(hard coded values) to configure TKR source controller package values. This should be replaced with the logic
+	// that fetches these values from tkg-bom(for bom related urls) and set the TKR source controller package values
+	var tkrRepoImagePath string
+	providerType := userProviderConfigValues[constants.ConfigVariableProviderType]
+	switch providerType {
+	case constants.InfrastructureProviderVSphere:
+		tkrRepoImagePath = fmt.Sprintf("%s/%s", tkgBomConfig.ImageConfig.ImageRepository, tkgBomConfig.TKRPackageRepo.VSphereNonparavirt)
+	case constants.InfrastructureProviderAWS:
+		tkrRepoImagePath = fmt.Sprintf("%s/%s", tkgBomConfig.ImageConfig.ImageRepository, tkgBomConfig.TKRPackageRepo.AWS)
+	case constants.InfrastructureProviderAzure:
+		tkrRepoImagePath = fmt.Sprintf("%s/%s", tkgBomConfig.ImageConfig.ImageRepository, tkgBomConfig.TKRPackageRepo.Azure)
+	default:
+		return "", errors.Errorf("unknown provider type %q", providerType)
+	}
+
 	tkgPackageConfig := TKGPackageConfig{
 		Metadata: Metadata{
-			InfraProvider: userProviderConfigValues[constants.ConfigVariableProviderType],
+			InfraProvider: userProviderConfigValues[constants.ConfigVariableProviderType].(string),
 		},
 		ConfigValues: userProviderConfigValues,
 		FrameworkPackage: FrameworkPackage{
@@ -56,6 +75,19 @@ func GetTKGPackageConfigValuesFileFromUserConfig(managementPackageVersion string
 				VersionConstraints: managementPackageVersion,
 			},
 		},
+		TKRSourceControllerPackage: TKRSourceControllerPackage{
+			VersionConstraints: managementPackageVersion,
+			TKRSourceControllerPackageValues: TKRSourceControllerPackageValues{
+				VersionConstraints:   managementPackageVersion,
+				BomImagePath:         fmt.Sprintf("%s/%s", tkgBomConfig.ImageConfig.ImageRepository, tkgBomConfig.TKRBOM.ImagePath),
+				BomMetadataImagePath: fmt.Sprintf("%s/%s", tkgBomConfig.ImageConfig.ImageRepository, tkgBomConfig.TKRCompatibility.ImagePath),
+				TKRRepoImagePath:     tkrRepoImagePath,
+				DefaultCompatibleTKR: tkgBomConfig.Default.TKRVersion,
+			},
+		},
+		CoreManagementPluginsPackage: CoreManagementPluginsPackage{
+			VersionConstraints: managementPackageVersion,
+		},
 	}
 
 	configBytes, err := yaml.Marshal(tkgPackageConfig)
diff --git a/pkg/v1/tkg/managementcomponents/types.go b/pkg/v1/tkg/managementcomponents/types.go
index 9c86b03e84..0170710224 100644
--- a/pkg/v1/tkg/managementcomponents/types.go
+++ b/pkg/v1/tkg/managementcomponents/types.go
@@ -5,10 +5,12 @@ package managementcomponents
 
 // TKGPackageConfig defines TKG package configuration
 type TKGPackageConfig struct {
-	Metadata            Metadata            `yaml:"metadata"`
-	ConfigValues        map[string]string   `yaml:"configvalues"`
-	FrameworkPackage    FrameworkPackage    `yaml:"frameworkPackage"`
-	ClusterClassPackage ClusterClassPackage `yaml:"clusterclassPackage"`
+	Metadata                     Metadata                     `yaml:"metadata"`
+	ConfigValues                 map[string]interface{}       `yaml:"configvalues"`
+	FrameworkPackage             FrameworkPackage             `yaml:"frameworkPackage"`
+	ClusterClassPackage          ClusterClassPackage          `yaml:"clusterclassPackage"`
+	TKRSourceControllerPackage   TKRSourceControllerPackage   `yaml:"tkrSourceControllerPackage"`
+	CoreManagementPluginsPackage CoreManagementPluginsPackage `yaml:"coreManagementPluginsPackage"`
 }
 
 // Metadata specifies metadata as part of TKG package config
@@ -16,6 +18,21 @@ type Metadata struct {
 	InfraProvider string `yaml:"infraProvider"`
 }
 
+type TKRSourceControllerPackage struct {
+	NamespaceForPackageInstallation  string                           `yaml:"namespaceForPackageInstallation,omitempty"`
+	VersionConstraints               string                           `yaml:"versionConstraints,omitempty"`
+	TKRSourceControllerPackageValues TKRSourceControllerPackageValues `yaml:"tkrSourceControllerPackageValues,omitempty"`
+}
+
+type TKRSourceControllerPackageValues struct {
+	Namespace            string `yaml:"namespace,omitempty"`
+	CreateNamespace      string `yaml:"createNamespace,omitempty"`
+	VersionConstraints   string `yaml:"versionConstraints,omitempty"`
+	BomImagePath         string `yaml:"bomImagePath,omitempty"`
+	BomMetadataImagePath string `yaml:"bomMetadataImagePath,omitempty"`
+	TKRRepoImagePath     string `yaml:"tkrRepoImagePath,omitempty"`
+	DefaultCompatibleTKR string `yaml:"defaultCompatibleTKR,omitempty"`
+}
 type FrameworkPackage struct {
 	NamespaceForPackageInstallation string                     `yaml:"namespaceForPackageInstallation,omitempty"`
 	VersionConstraints              string                     `yaml:"versionConstraints,omitempty"`
@@ -39,6 +56,15 @@ type AddonsFeatureGates struct {
 type TanzuAddonsManager struct {
 	FeatureGates AddonsFeatureGates `yaml:"featureGates,omitempty"`
 }
+type CoreManagementPluginsPackage struct {
+	NamespaceForPackageInstallation   string                            `yaml:"namespaceForPackageInstallation,omitempty"`
+	VersionConstraints                string                            `yaml:"versionConstraints,omitempty"`
+	CoreManagementPluginsPackageValue CoreManagementPluginsPackageValue `yaml:"clusterclassInfraPackageValues,omitempty"`
+}
+
+type CoreManagementPluginsPackageValue struct {
+	DeployCLIPluginCRD bool `yaml:"deployCLIPluginCRD,omitempty"`
+}
 
 type AddonsManagerPackageValues struct {
 	VersionConstraints string             `yaml:"versionConstraints,omitempty"`
diff --git a/pkg/v1/tkg/tkgconfigbom/bom_types.go b/pkg/v1/tkg/tkgconfigbom/bom_types.go
index e1df6a61a6..4d65b01b86 100644
--- a/pkg/v1/tkg/tkgconfigbom/bom_types.go
+++ b/pkg/v1/tkg/tkgconfigbom/bom_types.go
@@ -115,6 +115,22 @@ type tkrBOMInfo struct {
 	ImagePath string `yaml:"imagePath"`
 }
 
+type tkrCompatibilityInfo struct {
+	ImagePath string `yaml:"imagePath"`
+}
+
+type tkrPackageRepo struct {
+	AWS                string `yaml:"aws"`
+	Azure              string `yaml:"azure"`
+	VSphereNonparavirt string `yaml:"vsphere-nonparavirt"`
+}
+
+type tkrPackage struct {
+	AWS                string `yaml:"aws"`
+	Azure              string `yaml:"azure"`
+	VSphereNonparavirt string `yaml:"vsphere-nonparavirt"`
+}
+
 // BOMConfiguration defines the struct to represent BOM information
 type BOMConfiguration struct {
 	Default               *defaultInfo                `yaml:"default"`
@@ -128,6 +144,9 @@ type BOMConfiguration struct {
 	ImageConfig           *imageConfig                `yaml:"imageConfig"`
 	Extensions            map[string]*extensionInfo   `yaml:"extensions,omitempty"`
 	TKRBOM                *tkrBOMInfo                 `yaml:"tkr-bom"`
+	TKRCompatibility      *tkrCompatibilityInfo       `yaml:"tkr-compatibility"`
+	TKRPackageRepo        *tkrPackageRepo             `yaml:"tkr-package-repo"`
+	TKRPackage            *tkrPackage                 `yaml:"tkr-package"`
 
 	ProvidersVersionMap map[string]string
 }
diff --git a/pkg/v1/tkg/tkgctl/config_cluster.go b/pkg/v1/tkg/tkgctl/config_cluster.go
index bef82449a4..6c754f68ed 100644
--- a/pkg/v1/tkg/tkgctl/config_cluster.go
+++ b/pkg/v1/tkg/tkgctl/config_cluster.go
@@ -28,7 +28,9 @@ func (t *tkgctl) ConfigCluster(configClusterOption CreateClusterOptions) error {
 		return err
 	}
 
-	options, err := t.getCreateClusterOptions(configClusterOption.ClusterName, &configClusterOption)
+	isInputFileClusterClassBased := false
+	// TODO (chandrareddyp) need to support Cluster.YAML file with Cluster Object for the dry-run use case, then based on input file type, pass the isInputFileClusterClassBased flag here (https://github.com/vmware-tanzu/tanzu-framework/issues/2516)
+	options, err := t.getCreateClusterOptions(configClusterOption.ClusterName, &configClusterOption, isInputFileClusterClassBased)
 	if err != nil {
 		return err
 	}
diff --git a/pkg/v1/tkg/tkgctl/create_cluster.go b/pkg/v1/tkg/tkgctl/create_cluster.go
index 03bd7b3da8..182e3e1431 100644
--- a/pkg/v1/tkg/tkgctl/create_cluster.go
+++ b/pkg/v1/tkg/tkgctl/create_cluster.go
@@ -4,8 +4,6 @@
 package tkgctl
 
 import (
-	"context"
-	"fmt"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -57,14 +55,11 @@ func (t *tkgctl) CreateCluster(cc CreateClusterOptions) error {
 	if cc.GenerateOnly {
 		return t.ConfigCluster(cc)
 	}
-	isInputFileClusterClassBased := false
-	isTKGSCluster := false
-	var err error
-	isInputFileClusterClassBased, err = t.processWorkloadClusterInputFile(&cc)
+	isTKGSCluster, err := t.tkgClient.IsPacificManagementCluster()
 	if err != nil {
-		return err
+		return errors.Wrap(err, "unable to determine if management cluster is on vSphere with Tanzu")
 	}
-	isTKGSCluster, err = t.processManagementClusterForTKGSCluster(isInputFileClusterClassBased)
+	isInputFileClusterClassBased, err := t.processWorkloadClusterInputFile(&cc, isTKGSCluster)
 	if err != nil {
 		return err
 	}
@@ -95,11 +90,10 @@ func (t *tkgctl) CreateCluster(cc CreateClusterOptions) error {
 
 	defer t.restoreAfterSettingTimeout(cc.Timeout)()
 
-	options, err := t.getCreateClusterOptions(cc.ClusterName, &cc)
+	options, err := t.getCreateClusterOptions(cc.ClusterName, &cc, isInputFileClusterClassBased)
 	if err != nil {
 		return err
 	}
-	options.IsInputFileClusterClassBased = isInputFileClusterClassBased
 
 	if isTKGSCluster {
 		// For TKGS kubernetesVersion will be same as TkrVersion
@@ -146,57 +140,68 @@ func (t *tkgctl) processManagementClusterInputFile(ir *InitRegionOptions) (bool,
 			return isInputFileClusterClassBased, err
 		}
 		if isInputFileClusterClassBased {
-			t.processCClusterObjectForConfigurationVariables(clusterobj)
-			t.overrideManagementClusterOptionsWithCClusterConfigurationValues(ir)
+			err = t.processClusterObjectForConfigurationVariables(clusterobj)
+			if err != nil {
+				return isInputFileClusterClassBased, err
+			}
+			t.overrideManagementClusterOptionsWithLatestEnvironmentConfigurationValues(ir)
 		}
 	}
 	return isInputFileClusterClassBased, nil
 }
 
-func (t *tkgctl) processWorkloadClusterInputFile(cc *CreateClusterOptions) (bool, error) {
+func (t *tkgctl) processWorkloadClusterInputFile(cc *CreateClusterOptions, isTKGSCluster bool) (bool, error) {
 	var clusterobj unstructured.Unstructured
 	var err error
 	isInputFileClusterClassBased := false
-
 	if t.tkgClient.IsFeatureActivated(config.FeatureFlagPackageBasedLCM) {
 		isInputFileClusterClassBased, clusterobj, err = t.checkIfInputFileIsClusterClassBased(cc.ClusterConfigFile)
 		if err != nil {
 			return isInputFileClusterClassBased, err
 		}
 		if isInputFileClusterClassBased {
-			t.processCClusterObjectForConfigurationVariables(clusterobj)
-			t.overrideClusterOptionsWithCClusterConfigurationValues(cc)
+			if isTKGSCluster {
+				t.TKGConfigReaderWriter().Set(constants.ConfigVariableClusterName, clusterobj.GetName())
+				t.TKGConfigReaderWriter().Set(constants.ConfigVariableNamespace, clusterobj.GetNamespace())
+			} else {
+				err = t.processClusterObjectForConfigurationVariables(clusterobj)
+				if err != nil {
+					return isInputFileClusterClassBased, err
+				}
+			}
+			t.overrideClusterOptionsWithLatestEnvironmentConfigurationValues(cc)
 		}
 	}
-	return isInputFileClusterClassBased, nil
-}
-
-func (t *tkgctl) processManagementClusterForTKGSCluster(isInputFileClusterClassBased bool) (bool, error) {
-	isTKGSCluster, err := t.tkgClient.IsPacificManagementCluster()
+	err = t.validateTKGSClusterClassFeatureGate(isInputFileClusterClassBased, isTKGSCluster)
 	if err != nil {
-		return isTKGSCluster, errors.Wrap(err, "unable to determine if management cluster is on vSphere with Tanzu")
+		return isInputFileClusterClassBased, err
 	}
+	return isInputFileClusterClassBased, nil
+}
 
-	if t.tkgClient.IsFeatureActivated(config.FeatureFlagPackageBasedLCM) {
-		if isInputFileClusterClassBased && isTKGSCluster {
+// validateTKGSClusterClassFeatureGate validates the TKGS clusterclass feature gate state
+func (t *tkgctl) validateTKGSClusterClassFeatureGate(isInputFileClusterClassBased, isTKGSCluster bool) error {
+	/*
+		// TODO (chandrareddyp): We have disabled it because the feature gate is not fully implemented in TKGS
+		if t.tkgClient.IsFeatureActivated(config.FeatureFlagPackageBasedLCM) && isInputFileClusterClassBased && isTKGSCluster {
 			isFeatureActivated, err := t.featureGateHelper.FeatureActivatedInNamespace(context.Background(), constants.CCFeature, constants.TKGSClusterClassNamespace)
 			if err != nil {
-				return isTKGSCluster, errors.Wrap(err, fmt.Sprintf("error while checking feature '%v' status in namespace '%v'", constants.CCFeature, constants.TKGSClusterClassNamespace))
+				return errors.Wrap(err, fmt.Sprintf("error while checking feature '%v' status in namespace '%v'", constants.CCFeature, constants.TKGSClusterClassNamespace))
 			}
 			if !isFeatureActivated {
-				return isTKGSCluster, fmt.Errorf("vSphere with Tanzu environment detected, however, the feature '%v' is not activated in '%v' namespace ", constants.CCFeature, constants.TKGSClusterClassNamespace)
+				return fmt.Errorf("vSphere with Tanzu environment detected, however, the feature '%v' is not activated in '%v' namespace ", constants.CCFeature, constants.TKGSClusterClassNamespace)
 			}
 		}
-	}
-	return isTKGSCluster, nil
+	*/
+	return nil
 }
 
-func (t *tkgctl) getCreateClusterOptions(name string, cc *CreateClusterOptions) (client.CreateClusterOptions, error) {
+func (t *tkgctl) getCreateClusterOptions(name string, cc *CreateClusterOptions, isInputFileClusterClassBased bool) (client.CreateClusterOptions, error) {
 	providerRepositorySource := &clusterctl.ProviderRepositorySourceOptions{
 		InfrastructureProvider: cc.InfrastructureProvider,
 		Flavor:                 cc.Plan,
 	}
-	if cc.Plan == "" {
+	if !isInputFileClusterClassBased && cc.Plan == "" {
 		return client.CreateClusterOptions{}, errors.New("required config variable 'CLUSTER_PLAN' not set")
 	}
 
@@ -224,14 +229,15 @@ func (t *tkgctl) getCreateClusterOptions(name string, cc *CreateClusterOptions)
 	}
 
 	return client.CreateClusterOptions{
-		ClusterConfigOptions:        configOptions,
-		NodeSizeOptions:             nodeSizeOptions,
-		CniType:                     cc.CniType,
-		VsphereControlPlaneEndpoint: cc.VsphereControlPlaneEndpoint,
-		ClusterOptionsEnableList:    clusterOptionsEnableList,
-		Edition:                     cc.Edition,
-		IsWindowsWorkloadCluster:    cc.IsWindowsWorkloadCluster,
-		ClusterConfigFile:           cc.ClusterConfigFile,
+		ClusterConfigOptions:         configOptions,
+		NodeSizeOptions:              nodeSizeOptions,
+		CniType:                      cc.CniType,
+		VsphereControlPlaneEndpoint:  cc.VsphereControlPlaneEndpoint,
+		ClusterOptionsEnableList:     clusterOptionsEnableList,
+		Edition:                      cc.Edition,
+		IsWindowsWorkloadCluster:     cc.IsWindowsWorkloadCluster,
+		ClusterConfigFile:            cc.ClusterConfigFile,
+		IsInputFileClusterClassBased: isInputFileClusterClassBased,
 	}, nil
 }
 
diff --git a/pkg/v1/tkg/tkgctl/helpers.go b/pkg/v1/tkg/tkgctl/helpers.go
index 5481d68a34..ad154c907b 100644
--- a/pkg/v1/tkg/tkgctl/helpers.go
+++ b/pkg/v1/tkg/tkgctl/helpers.go
@@ -5,8 +5,13 @@ package tkgctl
 
 import (
 	"fmt"
+	"net"
 	"os"
 	"path/filepath"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
 
 	"github.com/pkg/errors"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
@@ -24,6 +29,11 @@ var okResponsesMap = map[string]struct{}{
 	"y": {},
 	"Y": {},
 }
+var errMessageIPv6EnabledCIDRHasNoIPv6 = "the isIPV6Primary: true, but the first value in CIDRs:\"%v\" is not ipv6"
+var errMessageCIDRsIPFamiliesNotSame = `the IP Families of input CIDRs: "%v":"%v" , "%v":"%v", both are not same IP Families`
+
+var regExMachineDep = regexp.MustCompile(constants.RegexpMachineDeploymentsOverrides)
+var regExpTopologyClassVal = regexp.MustCompile(constants.RegexpTopologyClassValue)
 
 func askForConfirmation(message string) error {
 	var response string
@@ -157,90 +167,366 @@ func (t *tkgctl) removeAuditLog(clusterName string) {
 // checkIfInputFileIsClusterClassBased checks user input file, if it has Cluster object then
 // reads all non-empty variables in cluster.spec.topology.variables, and updates those variables in
 // environment and also CreateClusterOptions.
+// TODO (chandrareddyp) : need to make sure the legacy validation error and log messages should not have legacy variable names in case of cluster class use case, should refer Cluster Object attributes (https://github.com/vmware-tanzu/tanzu-framework/issues/2443)
 func (t *tkgctl) checkIfInputFileIsClusterClassBased(clusterConfigFile string) (bool, unstructured.Unstructured, error) {
-	var clusterobj unstructured.Unstructured
+	var clusterObj unstructured.Unstructured
 
 	isInputFileClusterClassBased := false
 	if clusterConfigFile == "" {
-		return isInputFileClusterClassBased, clusterobj, nil
+		return isInputFileClusterClassBased, clusterObj, nil
 	}
 	content, err := os.ReadFile(clusterConfigFile)
 	if err != nil {
-		return isInputFileClusterClassBased, clusterobj, errors.Wrap(err, fmt.Sprintf("Unable to read input file: %v ", clusterConfigFile))
+		return isInputFileClusterClassBased, clusterObj, errors.Wrap(err, fmt.Sprintf("Unable to read input file: %v ", clusterConfigFile))
 	}
 	yamlObjects, err := utilyaml.ToUnstructured(content)
 	if err != nil {
-		return isInputFileClusterClassBased, clusterobj, errors.Wrap(err, fmt.Sprintf("Input file content is not yaml formatted, file path: %v", clusterConfigFile))
+		return isInputFileClusterClassBased, clusterObj, errors.Wrap(err, fmt.Sprintf("Input file content is not yaml formatted, file path: %v", clusterConfigFile))
 	}
 
 	for i := range yamlObjects {
 		obj := yamlObjects[i]
 		if obj.GetKind() == constants.KindCluster {
 			isInputFileClusterClassBased = true
-			clusterobj = obj
+			clusterObj = obj
 			break
 		}
 	}
-	return isInputFileClusterClassBased, clusterobj, nil
-}
-
-// processCClusterObjectForConfigurationVariables takes ccluster object, process it to capture all configuration variables and add them in environment.
-func (t *tkgctl) processCClusterObjectForConfigurationVariables(cclusterObj unstructured.Unstructured) {
-	variablesMap := make(map[string]string)
-	variablesMap[constants.ConfigVariableClusterName] = cclusterObj.GetName()
-	variablesMap[constants.ConfigVariableNamespace] = cclusterObj.GetNamespace()
-	spec := cclusterObj.Object["spec"].(map[string]interface{})
-	if spec != nil {
-		topology := spec["topology"].(map[string]interface{})
-		if topology != nil {
-			variables := topology["variables"].([]interface{})
-			if variables != nil {
-				for j := range variables {
-					var name string
-					var value string
-					for k := range variables[j].(map[string]interface{}) {
-						if k == "name" {
-							name = variables[j].(map[string]interface{})[k].(string)
-						} else {
-							value = fmt.Sprintf("%v", variables[j].(map[string]interface{})[k])
+	return isInputFileClusterClassBased, clusterObj, nil
+}
+
+// processClusterObjectForConfigurationVariables takes cluster object, process it to capture all configuration variables and add them in environment.
+// TODO (chandrareddyp): validate the cluster class inputs without mapping to legacy variables and deprecate legacy validation (https://github.com/vmware-tanzu/tanzu-framework/issues/2432)
+func (t *tkgctl) processClusterObjectForConfigurationVariables(clusterObj unstructured.Unstructured) error {
+	inputVariablesMap := make(map[string]interface{})
+	inputVariablesMap["metadata.name"] = clusterObj.GetName()
+	inputVariablesMap["metadata.namespace"] = clusterObj.GetNamespace()
+	spec := clusterObj.Object[constants.SPEC].(map[string]interface{})
+	err := processYamlObjectAndAddToMap(spec, constants.SPEC, inputVariablesMap)
+	if err != nil {
+		return err
+	}
+
+	// TODO (chandrareddyp): Validate the cluster class and identify the provider type  by querying the cluster class object instead of depending on the cluster class name (https://github.com/vmware-tanzu/tanzu-framework/issues/2424)
+	providerName, err := getProviderNameFromTopologyClassName(inputVariablesMap[constants.TopologyClass])
+	// TODO (chandrareddyp) : Allow user to create workload cluster by disabling validation when provider type is unknown (https://github.com/vmware-tanzu/tanzu-framework/issues/2433)
+	if err != nil {
+		return err
+	}
+
+	// get infra specific variable map
+	clusterAttributePathToLegacyVarNameMap := constants.InfrastructureSpecificVariableMappingMap[providerName]
+
+	// assign cluster class input values to legacy variables
+	legacyVarMap := make(map[string]string)
+	for inputVariable := range inputVariablesMap {
+		if legacyNameForClusterObjectInputVariable, ok := clusterAttributePathToLegacyVarNameMap[inputVariable]; ok {
+			legacyVarMap[legacyNameForClusterObjectInputVariable] = fmt.Sprintf("%v", inputVariablesMap[inputVariable])
+		}
+	}
+	legacyVarMap[constants.ConfigVariableInfraProvider] = providerName
+
+	// Some properties (NODE_MACHINE_TYPE_1, NODE_MACHINE_TYPE_2, etc)
+	// can have two values from Cluster object attributes, key and value of constants.ClusterAttributesHigherPrecedenceToLowerMap are two attribute paths points to same legacy variable.
+	// eg: key - "spec.topology.workers.machineDeployments.1.variables.overrides.NODE_MACHINE_TYPE", value - "spec.topology.variables.nodes.1.machineType"
+	// these two key/value attribute paths mapped to NODE_MACHINE_TYPE_1 legacy variable, if these two attribute paths has values in Cluster Object
+	// then need to consider higher precedence attribute path value which is key of constants.ClusterAttributesHigherPrecedenceToLowerMap.
+	for higherPrecedenceKey := range constants.ClusterAttributesHigherPrecedenceToLowerMap {
+		legacyName, ok1 := clusterAttributePathToLegacyVarNameMap[higherPrecedenceKey]
+		value, ok2 := inputVariablesMap[higherPrecedenceKey]
+		if ok1 && ok2 {
+			legacyVarMap[legacyName] = fmt.Sprintf("%v", value)
+		}
+	}
+
+	// Identify TKG_IP_FAMILY based on Cluster and Service CIDRs, we need to set TKG_IP_FAMILY value, because we need this value for legacy validation in cluster creation flow. Cluster CIDR and Service CIDR IP Family's should be same, either "ipv4", "ip6", or dual stack ("ipv4,ipv6" or "ipv6,ipv4")
+	// If Cluster Attribute isIPV6Primary is true, then the first value of cluster/service CIDR should be ipv6 otherwise throws error.
+	// If isIPV6Primary is true, and cluster/service CIDR is dual stack, then the IP Family value should be "ipv6,ipv4" (ipv6 should come first), if isIPV6Primary is not true and  cluster/service CIDR is dual stack then IP Family value should be "ipv4,ipv6"
+	var isIPV6Primary bool
+	if legacyVarMap[constants.TKGIPV6Primary] != "" {
+		isIPV6Primary, _ = strconv.ParseBool(legacyVarMap[constants.TKGIPV6Primary])
+	}
+	clusterCIDRs := stringArrayToStringWithCommaSeparatedElements(legacyVarMap[constants.ConfigVariableClusterCIDR])
+	serviceCIDRs := stringArrayToStringWithCommaSeparatedElements(legacyVarMap[constants.ConfigVariableServiceCIDR])
+	IPFamily, err := GetIPFamilyForGivenClusterNetworkCIDRs(clusterCIDRs, serviceCIDRs, isIPV6Primary)
+	if err != nil {
+		return err
+	}
+	legacyVarMap[constants.TKGIPFamily] = IPFamily
+
+	// update legacyVarMap in environment
+	t.TKGConfigReaderWriter().SetMap(legacyVarMap)
+	return nil
+}
+
+// processYamlObjectAndAddToMap process specific value of the Cluster yaml object
+// value is the value for the given attribute path clusterAttributePath in Cluster object
+// if input value is final child value then value is added to variablesMap with clusterAttributePath as key,
+// if the input value is not final child value, then its process again for next level child.
+func processYamlObjectAndAddToMap(value interface{}, clusterAttributePath string, inputVariablesMap map[string]interface{}) error {
+	var err error
+	switch value := value.(type) {
+	case []interface{}:
+		err = processYamlObjectArrayInterfaceType(value, clusterAttributePath, inputVariablesMap)
+	case []map[string]interface{}:
+		for index := range value {
+			err = processYamlObjectAndAddToMap(value[index], clusterAttributePath, inputVariablesMap)
+			if err != nil {
+				return err
+			}
+		}
+	case map[string]interface{}:
+		for key := range value {
+			nextLevelName := key
+			nextLevelVal := value[nextLevelName]
+			nextLevelFullPath := clusterAttributePath + "." + nextLevelName
+			// There are attributes which has value of type array, no need to process those variables values further
+			// convert array data into a string (with comma separated elements) and assign the value
+			if _, ok := constants.ClusterAttributesWithArrayTypeValue[nextLevelFullPath]; ok && nextLevelVal != nil {
+				inputVariablesMap[nextLevelFullPath] = stringArrayToStringWithCommaSeparatedElements(fmt.Sprintf("%v", nextLevelVal))
+			} else {
+				err = processYamlObjectAndAddToMap(nextLevelVal, nextLevelFullPath, inputVariablesMap)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	case interface{}:
+		if _, ok := inputVariablesMap[clusterAttributePath]; ok {
+			log.Warningf("duplicate variable in input cluster class config file, variable path: %v", clusterAttributePath)
+		} else if fmt.Sprintf("%v", value) != "" {
+			inputVariablesMap[clusterAttributePath] = value
+			// if path spec.topology.variables.network.proxy has any child attributes then enable TKG_HTTP_PROXY_ENABLED, spec.topology.variables.network.proxy mapped to TKG_HTTP_PROXY_ENABLED
+			if strings.HasPrefix(clusterAttributePath, "spec.topology.variables.network.proxy") {
+				inputVariablesMap["spec.topology.variables.network.proxy"] = true
+			}
+		}
+	default:
+		if value != nil {
+			errInfo := fmt.Errorf("unsupported input value type:%v in input cluster class file attribute at:%v", reflect.TypeOf(value), clusterAttributePath)
+			return errInfo
+		}
+	}
+	return err
+}
+
+// processYamlObjectArrayInterfaceType process array interface type, does handles some special cases of cluster class attribute paths
+func processYamlObjectArrayInterfaceType(value []interface{}, clusterAttributePath string, inputVariablesMap map[string]interface{}) error {
+	var err error
+	for index := range value {
+		if clusterAttributePath == constants.TopologyVariablesNetworkSubnets || clusterAttributePath == constants.TopologyVariablesNodes || clusterAttributePath == constants.TopologyWorkersMachineDeployments {
+			err = processYamlObjectAndAddToMap(value[index], clusterAttributePath+"."+strconv.Itoa(index), inputVariablesMap)
+		} else if regExMachineDep.MatchString(clusterAttributePath) || clusterAttributePath == constants.TopologyVariables {
+			// The attribute paths - spec.topology.workers.machineDeployments.[0-9].variables.overrides, spec.topology.variables
+			// has array of data, each array element is of type map, with key(as "name")/value (as "value")
+			// to organize better, get "name" and "value", append "name" value to attribute path and "value" value as value, process them as next level.
+			variables := value
+			for varIndex := range variables {
+				nameValueMap := variables[varIndex].(map[string]interface{})
+				varName := nameValueMap["name"]
+				varValue := nameValueMap["value"]
+				nextLevelName := clusterAttributePath + "." + varName.(string)
+				// The attribute path "spec.topology.variables.trust.*" has value of type array, each array element is of type map, map has keys - "name" and "data",
+				// need to process "spec.topology.variables.trust."+ (value of "name") as attribute path and value of "data" next level value, process it again.
+				if varName == "trust" {
+					trustValArr := varValue.([]interface{})
+					for trustIndex := range trustValArr {
+						trustName := trustValArr[trustIndex].(map[string]interface{})["name"].(string)
+						trustData := trustValArr[trustIndex].(map[string]interface{})["data"]
+						err = processYamlObjectAndAddToMap(trustData, nextLevelName+"."+trustName, inputVariablesMap)
+						if err != nil {
+							return err
 						}
 					}
-					if len(value) > 0 {
-						variablesMap[name] = value
-					}
+					continue // we are done processing "trust" variable, so process next variable
+				} else if varName == "TKR_DATA" { // no need to process TKR_DATA, because there is no mapping as of now
+					continue
+				}
+				err = processYamlObjectAndAddToMap(varValue, nextLevelName, inputVariablesMap)
+				if err != nil {
+					return err
 				}
-				t.TKGConfigReaderWriter().SetMap(variablesMap)
 			}
+			break // all variables are processed in above loop so break it.
+		} else {
+			// process specific index value, this index value could be of any type
+			err = processYamlObjectAndAddToMap(value[index], clusterAttributePath, inputVariablesMap)
+		}
+		if err != nil {
+			return err
 		}
 	}
+	return err
 }
 
-// overrideClusterOptionsWithCClusterConfigurationValues overrides CreateClusterOptions attributes with latest values from the environment.
-func (t *tkgctl) overrideClusterOptionsWithCClusterConfigurationValues(cc *CreateClusterOptions) {
-	cc.ClusterName, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableClusterName)
-	cc.Namespace, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableNamespace)
-	cc.Plan, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableClusterPlan)
-	cc.Namespace, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableNamespace)
-	cc.InfrastructureProvider, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableInfraProvider)
-	cc.ControlPlaneMachineCount, _ = tkgconfighelper.GetIntegerVariableFromConfig(constants.ConfigVariableControlPlaneMachineCount, t.TKGConfigReaderWriter())
-	cc.WorkerMachineCount, _ = tkgconfighelper.GetIntegerVariableFromConfig(constants.ConfigVariableWorkerMachineCount, t.TKGConfigReaderWriter())
-	cc.Size, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableSize)
-	cc.ControlPlaneSize, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableControlPlaneSize)
-	cc.WorkerSize, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableWorkerSize)
-	cc.CniType, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableCNI)
-	cc.EnableClusterOptions, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableEnableClusterOptions)
-	cc.VsphereControlPlaneEndpoint, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableVsphereControlPlaneEndpoint)
-}
-
-// overrideManagementClusterOptionsWithCClusterConfigurationValues overrides InitRegion attributes with latest values from the environment.
-func (t *tkgctl) overrideManagementClusterOptionsWithCClusterConfigurationValues(ir *InitRegionOptions) {
-	ir.ClusterName, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableClusterName)
-	ir.Namespace, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableNamespace)
-	ir.Plan, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableClusterPlan)
-	ir.InfrastructureProvider, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableInfraProvider)
-	ir.Size, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableSize)
-	ir.ControlPlaneSize, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableControlPlaneSize)
-	ir.WorkerSize, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableWorkerSize)
-	ir.CniType, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableCNI)
-	ir.VsphereControlPlaneEndpoint, _ = t.TKGConfigReaderWriter().Get(constants.ConfigVariableVsphereControlPlaneEndpoint)
+// getProviderNameFromTopologyClassName takes input cluster class spec.topology.class value and validates, returns provides name.
+// The Cluster spec.topology.class attribute value should be valid kubernetes object name : it should be string,
+// should be splittable with "-", after split, it should have at least 3 parts, second part should be infra provider name - [aws, azure, vsphere, docker]
+// eg: tkg-aws-default : infra provider is aws.
+// tkg-unknown-cluster1 : this is not valid name,  "unknown" is not valid infra provider name.
+func getProviderNameFromTopologyClassName(topologyClassValue interface{}) (string, error) {
+	var provider string
+	if topologyClassValue == nil || !regExpTopologyClassVal.MatchString(topologyClassValue.(string)) {
+		return provider, errors.New(constants.TopologyClassIncorrectValueErrMsg)
+	}
+	return strings.Split(topologyClassValue.(string), "-")[1], nil
+}
+
+// overrideClusterOptionsWithLatestEnvironmentConfigurationValues overrides CreateClusterOptions attributes with latest values
+// from the environment only if environment has value, the variable values in environment could be updated from input config file or input cluster class file.
+func (t *tkgctl) overrideClusterOptionsWithLatestEnvironmentConfigurationValues(cc *CreateClusterOptions) {
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableClusterName); err == nil {
+		cc.ClusterName = val
+	}
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableClusterPlan); err == nil {
+		cc.Plan = val
+	}
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableNamespace); err == nil {
+		cc.Namespace = val
+	}
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableInfraProvider); err == nil {
+		cc.InfrastructureProvider = val
+	}
+	if val, err := tkgconfighelper.GetIntegerVariableFromConfig(constants.ConfigVariableControlPlaneMachineCount, t.TKGConfigReaderWriter()); err == nil {
+		cc.ControlPlaneMachineCount = val
+	}
+	if val, err := tkgconfighelper.GetIntegerVariableFromConfig(constants.ConfigVariableWorkerMachineCount, t.TKGConfigReaderWriter()); err == nil {
+		cc.WorkerMachineCount = val
+	}
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableSize); err == nil {
+		cc.Size = val
+	}
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableControlPlaneSize); err == nil {
+		cc.ControlPlaneSize = val
+	}
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableWorkerSize); err == nil {
+		cc.WorkerSize = val
+	}
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableCNI); err == nil {
+		cc.CniType = val
+	}
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableEnableClusterOptions); err == nil {
+		cc.EnableClusterOptions = val
+	}
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableVsphereControlPlaneEndpoint); err == nil {
+		cc.VsphereControlPlaneEndpoint = val
+	}
+}
+
+// overrideManagementClusterOptionsWithLatestEnvironmentConfigurationValues overrides InitRegion attributes with latest values
+// from the environment only if environment has value, the variable values in environment could be updated from input config file or input cluster class file.
+func (t *tkgctl) overrideManagementClusterOptionsWithLatestEnvironmentConfigurationValues(ir *InitRegionOptions) {
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableClusterName); err == nil {
+		ir.ClusterName = val
+	}
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableNamespace); err == nil {
+		ir.Namespace = val
+	}
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableClusterPlan); err == nil {
+		ir.Plan = val
+	}
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableInfraProvider); err == nil {
+		ir.InfrastructureProvider = val
+	}
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableSize); err == nil {
+		ir.Size = val
+	}
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableControlPlaneSize); err == nil {
+		ir.ControlPlaneSize = val
+	}
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableWorkerSize); err == nil {
+		ir.WorkerSize = val
+	}
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableCNI); err == nil {
+		ir.CniType = val
+	}
+	if val, err := t.TKGConfigReaderWriter().Get(constants.ConfigVariableVsphereControlPlaneEndpoint); err == nil {
+		ir.VsphereControlPlaneEndpoint = val
+	}
+}
+
+// GetIPFamilyForGivenClusterNetworkCIDRs takes clusterNetwork's pods CIDRs and service CIDRs, and returns IP family type
+// The each input cidrs string can have multiple CIDR's separated with comma (,), but it can not have more than two on each input CIDR string.
+// If input CIDR has both ipv6 and ipv4, and if isIPV6Primary is true then the first CIDR should be ipv6, and returns "ipv6,ipv4",  else if isIPV6Primary is false then returns "ipv4,ipv6"
+// both input CIDRs should be same family
+func GetIPFamilyForGivenClusterNetworkCIDRs(podsCIDRs, serviceCIDRs string, isIPV6Primary bool) (string, error) {
+	DefaultIPFamily := constants.IPv4Family
+	var podsIPFamily, serviceIPFamily string
+	var err error
+	if podsCIDRs != "" {
+		podsIPFamily, err = GetIPFamilyForGivenCIDRs(strings.Split(podsCIDRs, ","), isIPV6Primary)
+		if err != nil {
+			return DefaultIPFamily, err
+		}
+	} else {
+		podsIPFamily = DefaultIPFamily
+	}
+	if serviceCIDRs != "" {
+		serviceIPFamily, err = GetIPFamilyForGivenCIDRs(strings.Split(serviceCIDRs, ","), isIPV6Primary)
+		if err != nil {
+			return DefaultIPFamily, err
+		}
+	} else {
+		serviceIPFamily = DefaultIPFamily
+	}
+
+	// If the IP Family of both CIDRs not same then return error
+	if serviceIPFamily != podsIPFamily {
+		return DefaultIPFamily, fmt.Errorf(errMessageCIDRsIPFamiliesNotSame, podsCIDRs, podsIPFamily, serviceCIDRs, serviceIPFamily)
+	}
+	return serviceIPFamily, nil
+}
+
+// stringArrayToStringWithCommaSeparatedElements converts given string (which has array data in fmt.Println output format) to string which has array elements separated with comma (,)
+// eg: Input string is "[100.96.0.0/11 100.64.0.0/18]" converts to "100.64.0.0/18,100.64.0.0/18" of string type.
+func stringArrayToStringWithCommaSeparatedElements(arrayDataInStringFormat string) string {
+	if arrayDataInStringFormat == "" {
+		return ""
+	}
+	return strings.Join(strings.Split(strings.Trim(arrayDataInStringFormat, "[]"), " "), ",")
+}
+
+// GetIPFamilyForGivenCIDRs takes cidrs array and returns ip family type (ipv4, ipv6 or dual)
+// Maximum input cidrs array length is 2 only - "[100.64.0.0/18,100.64.0.0/18]"
+// If input cidr's can be  ipv4, ipv6 or both.
+// if isIPV6Primary is true then the first cidrs value, which is cidrs[0] must be ipv6 otherwise throws error
+// if input cidrs has both ipv6 and ipv4 then returns "ipv6,ipv4" only if isIPV6Primary true, otherwise returns "ipv4,ipv6"
+// If all input cidr's has only ipv6 then returns "ipv6"
+// If all input cidr's has only ipv4 then returns "ipv4"
+func GetIPFamilyForGivenCIDRs(cidrs []string, isIPV6Primary bool) (string, error) {
+	DefaultIPFamily := constants.IPv4Family
+	if len(cidrs) > 2 {
+		return DefaultIPFamily, fmt.Errorf("too many CIDRs specified: %v", cidrs)
+	}
+	var foundIPv4 bool
+	var foundIPv6 bool
+	for i, cidr := range cidrs {
+		ip, _, err := net.ParseCIDR(cidr)
+		if err != nil {
+			return DefaultIPFamily, fmt.Errorf("could not parse CIDR %v, error: %s", cidr, err)
+		}
+		if ip.To4() != nil {
+			foundIPv4 = true
+			// if isIPV6Primary true, then the first value should be ipv6 family otherwise throw error
+			if isIPV6Primary && i == 0 {
+				return DefaultIPFamily, fmt.Errorf(errMessageIPv6EnabledCIDRHasNoIPv6, cidrs)
+			}
+		} else {
+			foundIPv6 = true
+		}
+	}
+	switch {
+	case foundIPv4 && foundIPv6:
+		if isIPV6Primary {
+			return constants.DualStackPrimaryIPv6Family, nil
+		}
+		// return "ipv4,ipv6" even first value is ipv6, if isIPV6Primary is false
+		return constants.DualStackPrimaryIPv4Family, nil
+	case foundIPv4:
+		return constants.IPv4Family, nil
+	case foundIPv6:
+		return constants.IPv6Family, nil
+	default:
+		return DefaultIPFamily, nil
+	}
 }
diff --git a/pkg/v1/tkg/utils/converter.go b/pkg/v1/tkg/utils/converter.go
new file mode 100644
index 0000000000..77e6df7693
--- /dev/null
+++ b/pkg/v1/tkg/utils/converter.go
@@ -0,0 +1,63 @@
+// Copyright 2022 VMware, Inc. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package utils
+
+import (
+	"strconv"
+
+	"gopkg.in/yaml.v3"
+)
+
+func Convert(in string) interface{} {
+	convs := []yamlScalarConvertable{
+		nullConvertable,
+		integerConvertable,
+		booleanConvertable,
+		floatConvertable,
+		structuredConvertable,
+	}
+
+	for _, conv := range convs {
+		value, convertable := conv(in)
+		if convertable {
+			return value
+		}
+	}
+	return in
+}
+
+type yamlScalarConvertable func(in string) (interface{}, bool)
+
+func structuredConvertable(in string) (interface{}, bool) {
+	var result interface{}
+	if err := yaml.Unmarshal([]byte(in), &result); err == nil && result != nil {
+		return result, true
+	}
+	return result, false
+}
+
+func nullConvertable(in string) (interface{}, bool) {
+	return nil, (in == "~" || in == "null")
+}
+
+func booleanConvertable(in string) (interface{}, bool) {
+	if v, err := strconv.ParseBool(in); err == nil {
+		return v, true
+	}
+	return false, false
+}
+
+func integerConvertable(in string) (interface{}, bool) {
+	if v, err := strconv.ParseUint(in, 0, 0); err == nil {
+		return v, true
+	}
+	return 0, false
+}
+
+func floatConvertable(in string) (interface{}, bool) {
+	if v, err := strconv.ParseFloat(in, 64); err == nil {
+		return v, true
+	}
+	return 0, false
+}


Test patch:
diff --git a/.github/workflows/tkg_integration_tests_clusterclass.yaml b/.github/workflows/tkg_integration_tests_clusterclass.yaml
index 6da6bb40ac..c199d1a0b2 100644
--- a/.github/workflows/tkg_integration_tests_clusterclass.yaml
+++ b/.github/workflows/tkg_integration_tests_clusterclass.yaml
@@ -187,7 +187,6 @@ jobs:
           AWS_REGION: "us-west-2"
           _MANAGEMENT_PACKAGE_REPO_IMAGE: gcr.io/eminent-nation-87317/tanzu_framework/github-actions/${{ steps.extract_reg_dir.outputs.regdir }}/management:v0.21.0
           _MANAGEMENT_PACKAGE_VERSION: "0.21.0"
-          _ADDITIONAL_MANAGEMENT_COMPONENT_CONFIGURATION_FILE: "https://gist.githubusercontent.com/anujc25/702a8a23a72af34da26360dd21ea331b/raw/a557004baa885fa2d8d7bbc4c672d2ca6b70fc31/tkr-addons-resources-v2-v1.23.5.yaml"
 
       - name: Cleanup AWS resources
         if: ${{ always() }}
diff --git a/pkg/v1/providers/tests/clustergen/run_tests.sh b/pkg/v1/providers/tests/clustergen/run_tests.sh
index a1e55f018e..7c0df70489 100755
--- a/pkg/v1/providers/tests/clustergen/run_tests.sh
+++ b/pkg/v1/providers/tests/clustergen/run_tests.sh
@@ -77,7 +77,31 @@ generate_cluster_configurations() {
         cat "$t" | perl -pe 's/--plan (\S+)/--plan $1cc/; s/_PLAN: (\S+)/_PLAN: $1cc/' > /tmp/test_tkg_config_cc
         echo "CLUSTER_CLASS: tkg-${infra}-default" >> /tmp/test_tkg_config_cc
         read -r -a cmdargs < <(grep EXE: /tmp/test_tkg_config_cc | cut -d: -f2-)
-        cat <<- EOF >> /tmp/test_tkg_config_cc
+
+        if [[ "${infra}" == "aws" ]]; then
+          cat <<- EOF >> /tmp/test_tkg_config_cc
+TKR_DATA: |-
+  v1.23.5+vmware.1:
+    kubernetesSpec:
+      version: v1.23.5+vmware.1
+      imageRepository: projects-stg.registry.vmware.com
+      etcd:
+        imageTag: v1.0.0-test
+      coredns:
+        imageTag: v1.1.0-test
+      kube-vip:
+        imageTag: v2.0.0-test
+    labels:
+      os-name: ubuntu
+      os-type: linux
+      os-arch: amd64
+    osImageRef:
+      id: test-ami-id
+      region: test-region
+EOF
+        fi
+        if [[ "${infra}" == "vsphere" ]]; then
+          cat <<- EOF >> /tmp/test_tkg_config_cc
 TKR_DATA: |-
   v1.21.2:
     kubernetesSpec:
@@ -93,6 +117,34 @@ TKR_DATA: |-
       os-name: ubuntu
       os-type: linux
       os-arch: amd64
+EOF
+        fi
+        if [[ "${infra}" == "azure" ]]; then
+          if grep -q "AZURE_IMAGE_GALLERY" /tmp/test_tkg_config_cc; then
+            cat <<- EOF >> /tmp/test_tkg_config_cc
+TKR_DATA: |-
+  v1.23.5+vmware.1:
+    kubernetesSpec:
+      version: v1.23.5+vmware.1
+      imageRepository: projects-stg.registry.vmware.com
+      etcd:
+        imageTag: v1.0.0-test
+      coredns:
+        imageTag: v1.1.0-test
+    labels:
+      os-name: ubuntu
+      os-type: linux
+      os-arch: amd64
+    osImageRef:
+      version: test-version
+      gallery: test-gallery
+      name: test-name
+      resourceGroup: test-resource-group
+      subscriptionID: test-subscription-id
+EOF
+          else
+            cat <<- EOF >> /tmp/test_tkg_config_cc
+TKR_DATA: |-
   v1.23.5+vmware.1:
     kubernetesSpec:
       version: v1.23.5+vmware.1
@@ -101,21 +153,20 @@ TKR_DATA: |-
         imageTag: v1.0.0-test
       coredns:
         imageTag: v1.1.0-test
-      kube-vip:
-        imageTag: v2.0.0-test
     labels:
       os-name: ubuntu
       os-type: linux
       os-arch: amd64
     osImageRef:
-      id: test-ami-id
-      region: test-region
       sku: test-sku
       publisher: test-publisher
       offer: test-offer
       version: test-version
       thirdPartyImage: test-third-party-image
 EOF
+          fi
+        fi
+
         echo $TKG --file /tmp/test_tkg_config_cc --configdir ${TKG_CONFIG_DIR} --log_file /tmp/"$t"_cc.log config cluster "${cmdargs[@]}"
         $TKG --file /tmp/test_tkg_config_cc --configdir ${TKG_CONFIG_DIR} --log_file /tmp/"$t"_cc.log config cluster "${cmdargs[@]}" 2>/tmp/err_cc.txt 1>/tmp/expected_cc.yaml
         #normalize_cc /tmp/expected_cc.yaml ${outputdir}/"$t".cc.output
diff --git a/pkg/v1/tkg/client/get_kubernetes_versions_test.go b/pkg/v1/tkg/client/get_kubernetes_versions_test.go
index 3848a78cc0..ec13073801 100644
--- a/pkg/v1/tkg/client/get_kubernetes_versions_test.go
+++ b/pkg/v1/tkg/client/get_kubernetes_versions_test.go
@@ -4,7 +4,6 @@
 package client_test
 
 import (
-	"fmt"
 	"os"
 	"path/filepath"
 	"time"
@@ -44,10 +43,13 @@ var _ = Describe("Unit tests for GetTanzuKubernetesReleases", func() {
 				regionalClusterClient.GetPacificTKCAPIVersionReturns("fake-api-versions", nil)
 				tkrInfo, err = tkgClient.DoGetTanzuKubernetesReleases(regionalClusterClient)
 			})
-			It("should return error", func() {
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring(fmt.Sprintf("Only %q Tanzu Kubernetes Cluster API version is supported by current version of Tanzu CLI", constants.DefaultPacificClusterAPIVersion)))
-			})
+			/*
+				TODO: (chandrareddyp) we need revisit below API Version validation, for now we disabled it.
+				It("should return error", func() {
+					Expect(err).To(HaveOccurred())
+					Expect(err.Error()).To(ContainSubstring(fmt.Sprintf("Only %q Tanzu Kubernetes Cluster API version is supported by current version of Tanzu CLI", constants.DefaultPacificClusterAPIVersion)))
+				})
+			*/
 		})
 		Context("When vSphere with Kubernetes does not support tanzukuberenetesrelease objects", func() {
 			JustBeforeEach(func() {
diff --git a/pkg/v1/tkg/client/management_components_test.go b/pkg/v1/tkg/client/management_components_test.go
index 2c3ccba1f6..23608b018f 100644
--- a/pkg/v1/tkg/client/management_components_test.go
+++ b/pkg/v1/tkg/client/management_components_test.go
@@ -22,7 +22,7 @@ var _ = Describe("Unit tests for GetUserConfigVariableValueMap", func() {
 		tkgClient                *TkgClient
 		configFilePath           string
 		configFileData           string
-		userProviderConfigValues map[string]string
+		userProviderConfigValues map[string]interface{}
 		rw                       tkgconfigreaderwriter.TKGConfigReaderWriter
 	)
 
@@ -32,6 +32,10 @@ var _ = Describe("Unit tests for GetUserConfigVariableValueMap", func() {
 ---
 ABC:
 PQR: ""
+Test1:
+Test2:
+Test3:
+Test4:
 `
 	sampleConfigFileData2 := ``
 
@@ -49,11 +53,19 @@ PQR: ""
 		BeforeEach(func() {
 			configFileData = sampleConfigFileData1
 			rw.Set("ABC", "abc-value")
+			rw.Set("Test1", "true")
+			rw.Set("Test2", "null")
+			rw.Set("Test3", "1")
+			rw.Set("Test4", "1.2")
 		})
 		It("returns userProviderConfigValues with ABC", func() {
 			Expect(err).NotTo(HaveOccurred())
-			Expect(len(userProviderConfigValues)).To(Equal(1))
+			Expect(len(userProviderConfigValues)).To(Equal(5))
 			Expect(userProviderConfigValues["ABC"]).To(Equal("abc-value"))
+			Expect(userProviderConfigValues["Test1"]).To(Equal(true))
+			Expect(userProviderConfigValues["Test2"]).To(BeNil())
+			Expect(userProviderConfigValues["Test3"]).To(Equal(uint64(1)))
+			Expect(userProviderConfigValues["Test4"]).To(Equal(1.2))
 		})
 	})
 
diff --git a/pkg/v1/tkg/managementcomponents/helper_test.go b/pkg/v1/tkg/managementcomponents/helper_test.go
new file mode 100644
index 0000000000..9b64ce36b7
--- /dev/null
+++ b/pkg/v1/tkg/managementcomponents/helper_test.go
@@ -0,0 +1,123 @@
+// Copyright 2021 VMware, Inc. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package managementcomponents_test
+
+import (
+	"os"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"gopkg.in/yaml.v3"
+
+	. "github.com/vmware-tanzu/tanzu-framework/pkg/v1/tkg/managementcomponents"
+	"github.com/vmware-tanzu/tanzu-framework/pkg/v1/tkg/tkgconfigbom"
+)
+
+var _ = Describe("Test GetTKGPackageConfigValuesFileFromUserConfig", func() {
+	var (
+		managementPackageVersion string
+		userProviderConfigValues map[string]interface{}
+		tkgBomConfigData         string
+		tkgBomConfig             *tkgconfigbom.BOMConfiguration
+		providerType             string
+		valuesFile               string
+		outputFile               string
+		err                      error
+	)
+
+	tkgBomConfigData = `apiVersion: run.tanzu.vmware.com/v1alpha2
+default:
+  k8sVersion: v1.23.5+vmware.1-tkg.1-fake
+release:
+  version: v1.6.0-fake
+imageConfig:
+  imageRepository: fake.custom.repo
+tkr-bom:
+  imagePath: tkr-bom
+tkr-compatibility:
+  imagePath: fake-path/tkr-compatibility
+tkr-package-repo:
+  aws: tkr-repository-aws
+  azure: tkr-repository-azure
+  vsphere-nonparavirt: tkr-repository-vsphere-nonparavirt
+tkr-package:
+  aws: tkr-aws
+  azure: tkr-azure
+  vsphere-nonparavirt: tkr-vsphere-nonparavirt
+`
+
+	JustBeforeEach(func() {
+		// Configure tkgBoMConfig
+		tkgBomConfig = &tkgconfigbom.BOMConfiguration{}
+		err = yaml.Unmarshal([]byte(tkgBomConfigData), tkgBomConfig)
+		Expect(err).NotTo(HaveOccurred())
+
+		// Configure user provider configuration
+		userProviderConfigValues = map[string]interface{}{
+			"PROVIDER_TYPE": providerType,
+		}
+
+		// invoke GetTKGPackageConfigValuesFileFromUserConfig for testing
+		valuesFile, err = GetTKGPackageConfigValuesFileFromUserConfig(managementPackageVersion, userProviderConfigValues, tkgBomConfig)
+	})
+
+	Context("When provider type is AWS", func() {
+		BeforeEach(func() {
+			managementPackageVersion = "v0.21.0"
+			providerType = "aws"
+			outputFile = "test/output_aws.yaml"
+		})
+		It("should not return error", func() {
+			Expect(err).NotTo(HaveOccurred())
+			f1, err := os.ReadFile(valuesFile)
+			Expect(err).NotTo(HaveOccurred())
+			f2, err := os.ReadFile(outputFile)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(string(f1)).To(Equal(string(f2)))
+		})
+	})
+
+	Context("When provider type is vSphere", func() {
+		BeforeEach(func() {
+			managementPackageVersion = "v0.21.0"
+			providerType = "vsphere"
+			outputFile = "test/output_vsphere.yaml"
+		})
+		It("should not return error", func() {
+			Expect(err).NotTo(HaveOccurred())
+			f1, err := os.ReadFile(valuesFile)
+			Expect(err).NotTo(HaveOccurred())
+			f2, err := os.ReadFile(outputFile)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(string(f1)).To(Equal(string(f2)))
+		})
+	})
+
+	Context("When provider type is Azure", func() {
+		BeforeEach(func() {
+			managementPackageVersion = "v0.21.0"
+			providerType = "azure"
+			outputFile = "test/output_azure.yaml"
+		})
+		It("should not return error", func() {
+			Expect(err).NotTo(HaveOccurred())
+			f1, err := os.ReadFile(valuesFile)
+			Expect(err).NotTo(HaveOccurred())
+			f2, err := os.ReadFile(outputFile)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(string(f1)).To(Equal(string(f2)))
+		})
+	})
+
+	Context("When provider type is not provided", func() {
+		BeforeEach(func() {
+			managementPackageVersion = "v0.21.0"
+			providerType = ""
+		})
+		It("should not return error", func() {
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("unknown provider type"))
+		})
+	})
+})
diff --git a/pkg/v1/tkg/managementcomponents/management_component_install_test.go b/pkg/v1/tkg/managementcomponents/management_component_install_test.go
index 7257ca34bf..173d0ae0cb 100644
--- a/pkg/v1/tkg/managementcomponents/management_component_install_test.go
+++ b/pkg/v1/tkg/managementcomponents/management_component_install_test.go
@@ -11,9 +11,8 @@ import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 
-	. "github.com/vmware-tanzu/tanzu-framework/pkg/v1/tkg/managementcomponents"
-
 	"github.com/vmware-tanzu/tanzu-framework/pkg/v1/tkg/fakes"
+	. "github.com/vmware-tanzu/tanzu-framework/pkg/v1/tkg/managementcomponents"
 )
 
 func Test(t *testing.T) {
diff --git a/pkg/v1/tkg/managementcomponents/test/output_aws.yaml b/pkg/v1/tkg/managementcomponents/test/output_aws.yaml
new file mode 100644
index 0000000000..2604c0f126
--- /dev/null
+++ b/pkg/v1/tkg/managementcomponents/test/output_aws.yaml
@@ -0,0 +1,33 @@
+metadata:
+    infraProvider: aws
+configvalues:
+    PROVIDER_TYPE: aws
+frameworkPackage:
+    versionConstraints: v0.21.0
+    featureGatesPackageValues:
+        versionConstraints: v0.21.0
+    tkrServicePackageValues:
+        versionConstraints: v0.21.0
+    clipluginsPackageValues:
+        versionConstraints: v0.21.0
+    addonsManagerPackageValues:
+        versionConstraints: v0.21.0
+        tanzuAddonsManager:
+            featureGates:
+                clusterBootstrapController: true
+    tanzuAuthPackageValues:
+        versionConstraints: v0.21.0
+clusterclassPackage:
+    versionConstraints: v0.21.0
+    clusterclassInfraPackageValues:
+        versionConstraints: v0.21.0
+tkrSourceControllerPackage:
+    versionConstraints: v0.21.0
+    tkrSourceControllerPackageValues:
+        versionConstraints: v0.21.0
+        bomImagePath: fake.custom.repo/tkr-bom
+        bomMetadataImagePath: fake.custom.repo/fake-path/tkr-compatibility
+        tkrRepoImagePath: fake.custom.repo/tkr-repository-aws
+        defaultCompatibleTKR: v1.23.5+vmware.1-tkg.1-fake
+coreManagementPluginsPackage:
+    versionConstraints: v0.21.0
diff --git a/pkg/v1/tkg/managementcomponents/test/output_azure.yaml b/pkg/v1/tkg/managementcomponents/test/output_azure.yaml
new file mode 100644
index 0000000000..603e0b2e67
--- /dev/null
+++ b/pkg/v1/tkg/managementcomponents/test/output_azure.yaml
@@ -0,0 +1,33 @@
+metadata:
+    infraProvider: azure
+configvalues:
+    PROVIDER_TYPE: azure
+frameworkPackage:
+    versionConstraints: v0.21.0
+    featureGatesPackageValues:
+        versionConstraints: v0.21.0
+    tkrServicePackageValues:
+        versionConstraints: v0.21.0
+    clipluginsPackageValues:
+        versionConstraints: v0.21.0
+    addonsManagerPackageValues:
+        versionConstraints: v0.21.0
+        tanzuAddonsManager:
+            featureGates:
+                clusterBootstrapController: true
+    tanzuAuthPackageValues:
+        versionConstraints: v0.21.0
+clusterclassPackage:
+    versionConstraints: v0.21.0
+    clusterclassInfraPackageValues:
+        versionConstraints: v0.21.0
+tkrSourceControllerPackage:
+    versionConstraints: v0.21.0
+    tkrSourceControllerPackageValues:
+        versionConstraints: v0.21.0
+        bomImagePath: fake.custom.repo/tkr-bom
+        bomMetadataImagePath: fake.custom.repo/fake-path/tkr-compatibility
+        tkrRepoImagePath: fake.custom.repo/tkr-repository-azure
+        defaultCompatibleTKR: v1.23.5+vmware.1-tkg.1-fake
+coreManagementPluginsPackage:
+    versionConstraints: v0.21.0
diff --git a/pkg/v1/tkg/managementcomponents/test/output_vsphere.yaml b/pkg/v1/tkg/managementcomponents/test/output_vsphere.yaml
new file mode 100644
index 0000000000..a1ea0e3fdd
--- /dev/null
+++ b/pkg/v1/tkg/managementcomponents/test/output_vsphere.yaml
@@ -0,0 +1,33 @@
+metadata:
+    infraProvider: vsphere
+configvalues:
+    PROVIDER_TYPE: vsphere
+frameworkPackage:
+    versionConstraints: v0.21.0
+    featureGatesPackageValues:
+        versionConstraints: v0.21.0
+    tkrServicePackageValues:
+        versionConstraints: v0.21.0
+    clipluginsPackageValues:
+        versionConstraints: v0.21.0
+    addonsManagerPackageValues:
+        versionConstraints: v0.21.0
+        tanzuAddonsManager:
+            featureGates:
+                clusterBootstrapController: true
+    tanzuAuthPackageValues:
+        versionConstraints: v0.21.0
+clusterclassPackage:
+    versionConstraints: v0.21.0
+    clusterclassInfraPackageValues:
+        versionConstraints: v0.21.0
+tkrSourceControllerPackage:
+    versionConstraints: v0.21.0
+    tkrSourceControllerPackageValues:
+        versionConstraints: v0.21.0
+        bomImagePath: fake.custom.repo/tkr-bom
+        bomMetadataImagePath: fake.custom.repo/fake-path/tkr-compatibility
+        tkrRepoImagePath: fake.custom.repo/tkr-repository-vsphere-nonparavirt
+        defaultCompatibleTKR: v1.23.5+vmware.1-tkg.1-fake
+coreManagementPluginsPackage:
+    versionConstraints: v0.21.0
diff --git a/pkg/v1/tkg/test/cc_setup.md b/pkg/v1/tkg/test/cc_setup.md
index 90312a5baf..e5839c1675 100644
--- a/pkg/v1/tkg/test/cc_setup.md
+++ b/pkg/v1/tkg/test/cc_setup.md
@@ -8,7 +8,6 @@
 ```bash
 export _MANAGEMENT_PACKAGE_REPO_IMAGE=gcr.io/eminent-nation-87317/tanzu_framework/github-actions/main/management:v0.21.0
 export _MANAGEMENT_PACKAGE_VERSION=0.21.0
-export _ADDITIONAL_MANAGEMENT_COMPONENT_CONFIGURATION_FILE=https://gist.githubusercontent.com/anujc25/702a8a23a72af34da26360dd21ea331b/raw/a557004baa885fa2d8d7bbc4c672d2ca6b70fc31/tkr-addons-resources-v2-v1.23.5.yaml
 ```
 
 - Make sure to enable the feature-flag for `package-based-lcm`
diff --git a/pkg/v1/tkg/tkgctl/create_cluster_test.go b/pkg/v1/tkg/tkgctl/create_cluster_test.go
index a04b4205ec..ac027d78f0 100644
--- a/pkg/v1/tkg/tkgctl/create_cluster_test.go
+++ b/pkg/v1/tkg/tkgctl/create_cluster_test.go
@@ -21,7 +21,14 @@ import (
 
 const fakeTKRVersion = "1.19.0+vmware.1-tkg.1"
 const configFilePath = "../fakes/config/config.yaml"
-const ccConfigFilePath = "../fakes/config/ccluster1_clusterOnly.yaml"
+
+const classInputFileAws = "../fakes/config/cluster_aws.yaml"
+const classInputFileAwsIncorrectClass = "../fakes/config/cluster_aws_incorrectClass.yaml"
+const classInputFileAwsEmptyClass = "../fakes/config/cluster_aws_emptyClass.yaml"
+const clusterInputFileMultipleObjectsAws = "../fakes/config/cluster_aws_multipleObjects.yaml"
+const classInputFileAzure = "../fakes/config/cluster_azure.yaml"
+const classInputFileVsphere = "../fakes/config/cluster_vsphere.yaml"
+const inputFileLegacy = "../fakes/config/cluster1_config.yaml"
 
 var testingDir string
 
@@ -204,7 +211,7 @@ var _ = Describe("Unit tests for getAndDownloadTkrIfNeeded", func() {
 	})
 })
 
-var _ = Describe("Unit tests for - ccluster.yaml as input file for 'tanzu cluster create -f ccluster' use case", func() {
+var _ = Describe("Unit tests for (AWS)  cluster_aws.yaml as input file for 'tanzu cluster create -f cluster_aws.yaml' use case", func() {
 	var (
 		ctl       tkgctl
 		tkgClient = &fakes.Client{}
@@ -222,112 +229,332 @@ var _ = Describe("Unit tests for - ccluster.yaml as input file for 'tanzu cluste
 		}
 		tkgClient.IsFeatureActivatedReturns(true)
 	})
-	Context("create cluster with ccluster.yaml : use cases", func() {
+	Context("When input Cluster object file is valid, plan is devcc:", func() {
 		BeforeEach(func() {
 			options = CreateClusterOptions{
 				ClusterName:            "test-cluster",
-				Plan:                   "dev",
+				Plan:                   "devcc",
 				InfrastructureProvider: "",
 				Namespace:              "",
 				GenerateOnly:           false,
 				TkrVersion:             fakeTKRVersion,
 				SkipPrompt:             true,
 				Edition:                "tkg",
-				ClusterConfigFile:      ccConfigFilePath,
+				ClusterConfigFile:      classInputFileAws,
 			}
 		})
-		It("Input file is ccluster type, make sure configurations are updated..", func() {
-			//Set some values before processing the input ccluster.yaml file.
-			ctl.TKGConfigReaderWriter().Set("CLUSTER_NAME", "BeforeCheckingInputFile")
-			vpcID := "VPC_ID_BeforeCheckingInputFile_11"
-			ctl.TKGConfigReaderWriter().Set("AWS_VPC_ID", vpcID)
-
-			//Process input ccluster.yaml file.
-			IsInputFileClusterClassBased, err := ctl.processWorkloadClusterInputFile(&options)
+		It("Environment should be updated with legacy variables and CreateClusterOptions updated with Cluster attribute values:", func() {
+			// Process input cluster yaml file, this should process input cluster yaml file
+			// and update the environment with legacy name and values
+			// most of cluster yaml attributes are mapped to legacy variable for more look this - constants.ClusterToLegacyVariablesMapAws
+			IsInputFileClusterClassBased, err := ctl.processWorkloadClusterInputFile(&options, false)
 			Expect(IsInputFileClusterClassBased).Should(BeTrue())
 			Expect(err).To(BeNil())
 
-			cname, _ := ctl.TKGConfigReaderWriter().Get("CLUSTER_NAME")
-			//cname should be same as CLUSTER_NAME value from the input config file options.ClusterConfigFile
-			// though we set before checking but it should override by the input ccluster.yaml file
-			Expect(cname).To(Equal("wcc2"))
-			vpcCIDR, _ := ctl.TKGConfigReaderWriter().Get("AWS_VPC_CIDR")
-			Expect(vpcCIDR).To(Equal("10.0.0.0/16"))
-			nodeType, _ := ctl.TKGConfigReaderWriter().Get("NODE_MACHINE_TYPE")
-			Expect(nodeType).To(Equal("m3.xlarge"))
-			tls, _ := ctl.TKGConfigReaderWriter().Get("TKG_CUSTOM_IMAGE_REPOSITORY_SKIP_TLS_VERIFY")
-			Expect(tls).To(Equal("true"))
-			//AWS_VPC_ID should be the same value what we set before processing, as this value is empty in ccluster.yaml file
-			vpcIDAfterProcess, _ := ctl.TKGConfigReaderWriter().Get("AWS_VPC_ID")
-			Expect(vpcIDAfterProcess).To(Equal(vpcID))
-		})
-		It("Input file is ccluster type with multiple objects.", func() {
-			//Set some values before processing the input ccluster.yaml file.
-			ctl.TKGConfigReaderWriter().Set("CLUSTER_NAME", "BeforeCheckingInputFile")
-			vpcID := "VPC_ID_BeforeCheckingInputFile_22"
-			ctl.TKGConfigReaderWriter().Set("AWS_VPC_ID", vpcID)
-
-			//Process input ccluster.yaml file.
-			options.ClusterConfigFile = "../fakes/config/ccluster2_multipleObjects.yaml"
-			IsInputFileClusterClassBased, err := ctl.processWorkloadClusterInputFile(&options)
+			// process input file and get map, which has all attribute's path and its values
+			inputVariablesMap := getInputAttributesMap(&ctl, options.ClusterConfigFile)
+
+			// updates lower precedence variables with higher precedence variables values.
+			// In AWS use case, there were few attributes repeated in cluster yaml file, we need to take always higher precedence values.
+			updateLowerPrecedenceVariablesWithHigherPrecedenceVariablesValues(inputVariablesMap)
+
+			// validate input Cluster Object yaml file attributes values with corresponding legacy variable values in environment, both should be same, as we have already updated the environment with Cluster Object attribute values.
+			validateFileInputAttributeValuesWithEnvironmentValues(&ctl, inputVariablesMap, constants.ClusterAttributesToLegacyVariablesMapAws)
+
+			// checking manually for some variables mapping values
+			mappedVal, _ := ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableClusterName)
+			Expect("aws-workload-cluster1").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// checking manually for some variables mapping values
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableNamespace)
+			Expect("default").To(Equal(fmt.Sprintf("%v", mappedVal)))
+			// Check the values in environment, should be updated from the cluster class input file
+			Expect("aws-workload-cluster1").To(Equal(options.ClusterName))
+			Expect("default").To(Equal(options.Namespace))
+			Expect("aws").To(Equal(options.InfrastructureProvider))
+			Expect(1).To(Equal(options.ControlPlaneMachineCount)) // mapped to CONTROL_PLANE_MACHINE_COUNT
+
+			// check value for "spec.clusterNetwork.services.cidrBlocks"
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableServiceCIDR)
+			Expect("2002::1234:abcd:ffff:c0a8:101/64,100.64.0.0/18").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for  TKG_IP_FAMILY which is decided based on "spec.clusterNetwork.services.cidrBlocks" and "spec.clusterNetwork.pod.cidrBlocks"
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.TKGIPFamily)
+			Expect(constants.DualStackPrimaryIPv6Family).To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for "spec.topology.variables.network.proxy.httpsProxy": TKGHTTPSProxy
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.TKGHTTPSProxy)
+			Expect("http://10.0.200.100").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for "spec.topology.variables.network.subnets.0.public.cidr":  ConfigVariableAWSPublicNodeCIDR
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableAWSPublicNodeCIDR)
+			Expect("10.1.1.0/24").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for "spec.topology.variables.network.subnets.2.private.id":   ConfigVariableAWSPrivateSubnetID2
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableAWSPrivateSubnetID2)
+			Expect("idValuePrivate2").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for "spec.topology.variables.network.vpc.existingID":         ConfigVariableAWSVPCID
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableAWSVPCID)
+			Expect("vpcID11").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for "spec.topology.variables.network.securityGroupOverrides.node":         ConfigVariableAWSSecurityGroupNode
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableAWSSecurityGroupNode)
+			Expect("securitygroupNode").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for "spec.topology.variables.trust.imageRepository" : ConfigVariableCustomImageRepositoryCaCertificate
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableCustomImageRepositoryCaCertificate)
+			Expect("trust.imageRepository.val").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for "spec.topology.variables.controlPlane.rootVolume.sizeGiB": ConfigVariableAWSControlplaneOsDiskSizeGib
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableAWSControlplaneOsDiskSizeGib)
+			Expect("80").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for spec.topology.workers.machineDeployments.0.replicas : ConfigVariableWorkerMachineCount0 - WORKER_MACHINE_COUNT_0
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableWorkerMachineCount0)
+			Expect("1").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// "spec.topology.workers.machineDeployments.2.variables.overrides.worker.instanceType": ConfigVariableNodeMachineType2, // NODE_MACHINE_TYPE_2
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableNodeMachineType2)
+			Expect("worker2").To(Equal(fmt.Sprintf("%v", mappedVal)))
+		})
+		It("When Input file is cluster type with multiple objects, Environment should be updated with legacy variables and CreateClusterOptions also updated with Cluster attribute values:", func() {
+
+			// Process input cluster yaml file, this should process input cluster yaml file
+			// and update the environment with legacy name and values
+			// most of cluster yaml attributes are mapped to legacy variable for more look this - constants.ClusterToLegacyVariablesMapAws
+			options.ClusterConfigFile = clusterInputFileMultipleObjectsAws
+			IsInputFileClusterClassBased, err := ctl.processWorkloadClusterInputFile(&options, false)
 			Expect(IsInputFileClusterClassBased).Should(BeTrue())
 			Expect(err).To(BeNil())
 
-			cname, _ := ctl.TKGConfigReaderWriter().Get("CLUSTER_NAME")
-			//cname should be same as CLUSTER_NAME value from the input config file options.ClusterConfigFile
-			// though we set before checking but it should override by the input ccluster.yaml file
-			Expect(cname).To(Equal("wcc11"))
-			vpcCIDR, _ := ctl.TKGConfigReaderWriter().Get("AWS_VPC_CIDR")
-			Expect(vpcCIDR).To(Equal("10.0.0.0/16"))
-			nodeType, _ := ctl.TKGConfigReaderWriter().Get("NODE_MACHINE_TYPE")
-			Expect(nodeType).To(Equal("m3.xlarge"))
-			tls, _ := ctl.TKGConfigReaderWriter().Get("TKG_CUSTOM_IMAGE_REPOSITORY_SKIP_TLS_VERIFY")
-			Expect(tls).To(Equal("false"))
-			repository, _ := ctl.TKGConfigReaderWriter().Get("TKG_CUSTOM_IMAGE_REPOSITORY")
-			Expect(repository).To(BeEmpty())
-			//AWS_VPC_ID should be the same value what we set before processing, as this value is empty in ccluster.yaml file
-			vpcIDAfterProcess, _ := ctl.TKGConfigReaderWriter().Get("AWS_VPC_ID")
-			Expect(vpcIDAfterProcess).To(Equal(vpcID))
-		})
-
-		It("make sure CreateClusterOptions values are updated.", func() {
-			options.ClusterName = "BeforeProcess"
-			options.Plan = "Plan"
-			//Process input ccluster.yaml file.
-			Expect(options.ClusterName).To(Equal("BeforeProcess"))
-			Expect(options.Plan).To(Equal("Plan"))
-
-			options.ClusterConfigFile = ccConfigFilePath
-			_, _ = ctl.processWorkloadClusterInputFile(&options)
-
-			cname, _ := ctl.TKGConfigReaderWriter().Get("CLUSTER_NAME")
-			Expect(cname).To(Equal("wcc2"))
-			Expect(options.ClusterName).To(Equal("wcc2"))
-			Expect(options.Plan).To(Equal("devcc"))
-		})
-
-		It("Input file is config.yaml file not ccluster.yaml file", func() {
-			options.ClusterConfigFile = "../fakes/config/ccluster1_config.yaml"
-			IsInputFileClusterClassBased, err := ctl.processWorkloadClusterInputFile(&options)
+			// process input file and get map, which has all attribute's path and its values
+			inputVariablesMap := getInputAttributesMap(&ctl, options.ClusterConfigFile)
+
+			// updates lower precedence variables with higher precedence variables values.
+			// In AWS use case, there were few attributes repeated in cluster yaml file, we need to take always higher precedence values.
+			updateLowerPrecedenceVariablesWithHigherPrecedenceVariablesValues(inputVariablesMap)
+
+			// validate input Cluster Object yaml file attributes values with corresponding legacy variable values in environment, both should be same, as we have already updated the environment with Cluster Object attribute values.
+			validateFileInputAttributeValuesWithEnvironmentValues(&ctl, inputVariablesMap, constants.ClusterAttributesToLegacyVariablesMapAws)
+
+			// checking manually for some variables mapping values
+			mappedVal, _ := ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableClusterName)
+			Expect("aws-workload-cluster1").To(Equal(fmt.Sprintf("%v", mappedVal)))
+		})
+
+		It("When Input file is cluster type does not have value for spec.topology.class, return an error", func() {
+
+			// Process input cluster.yaml file, this should process input cluster.yaml file
+			// and update the environment with legacy name and values
+			// most of cluster.yaml attributes are mapped to legacy variable for more look this - constants.clusterToLegacyVariablesMapAws
+			options.ClusterConfigFile = classInputFileAwsEmptyClass
+			_, err := ctl.processWorkloadClusterInputFile(&options, false)
+			Expect(fmt.Sprint(err)).To(Equal(constants.TopologyClassIncorrectValueErrMsg))
+		})
+
+		It("When Input file is aws clusterclass.yaml file, but in-correct spec.topology.class name:", func() {
+			options.ClusterConfigFile = classInputFileAwsIncorrectClass
+			IsInputFileClusterClassBased, err := ctl.processWorkloadClusterInputFile(&options, false)
+			Expect(IsInputFileClusterClassBased).Should(BeTrue())
+			Expect(fmt.Sprint(err)).To(Equal(constants.TopologyClassIncorrectValueErrMsg))
+		})
+
+		It("When Input file is config.yaml file not cluster.yaml file", func() {
+			options.ClusterConfigFile = inputFileLegacy
+			IsInputFileClusterClassBased, err := ctl.processWorkloadClusterInputFile(&options, false)
 			Expect(IsInputFileClusterClassBased).Should(BeFalse())
 			Expect(err).To(BeNil())
 		})
 
-		It("Input file is not specified", func() {
+		It("When Input file is not specified, return an error", func() {
 			options.ClusterConfigFile = ""
-			IsInputFileClusterClassBased, _ := ctl.processWorkloadClusterInputFile(&options)
+			IsInputFileClusterClassBased, _ := ctl.processWorkloadClusterInputFile(&options, false)
 			Expect(IsInputFileClusterClassBased).Should(BeFalse())
 		})
 
-		It("Input file not exists", func() {
+		It("When Input file not exists, return an error", func() {
 			options.ClusterConfigFile = "NOT-EXISTS"
-			_, err := ctl.processWorkloadClusterInputFile(&options)
+			_, err := ctl.processWorkloadClusterInputFile(&options, false)
 			Expect(err).To(HaveOccurred())
 		})
 	})
 })
 
-var _ = Describe("Unit tests for feature flag (config.FeatureFlagPackageBasedLCM) and featureGate for clusterclass - TKGS ", func() {
+var _ = Describe("Unit tests for - (Vsphere) - cluster_vsphere.yaml as input file for 'tanzu cluster create -f cluster_vsphere.yaml' use case", func() {
+	var (
+		ctl       tkgctl
+		tkgClient = &fakes.Client{}
+		bomClient = &fakes.TKGConfigBomClient{}
+		options   CreateClusterOptions
+	)
+	JustBeforeEach(func() {
+		tkgConfigReaderWriter, _ := tkgconfigreaderwriter.NewReaderWriterFromConfigFile(configFilePath, configFilePath)
+		ctl = tkgctl{
+			configDir:              testingDir,
+			tkgClient:              tkgClient,
+			tkgConfigReaderWriter:  tkgConfigReaderWriter,
+			tkgConfigUpdaterClient: tkgconfigupdater.New(testingDir, nil, tkgConfigReaderWriter),
+			tkgBomClient:           bomClient,
+		}
+		tkgClient.IsFeatureActivatedReturns(true)
+	})
+	Context("When input file is valid Cluster Class, plan devcc:", func() {
+		BeforeEach(func() {
+			options = CreateClusterOptions{
+				ClusterName:            "test-cluster",
+				Plan:                   "devcc",
+				InfrastructureProvider: "",
+				Namespace:              "",
+				GenerateOnly:           false,
+				TkrVersion:             fakeTKRVersion,
+				SkipPrompt:             true,
+				Edition:                "tkg",
+				ClusterConfigFile:      classInputFileVsphere,
+			}
+		})
+		It("Environment should be updated with legacy variables with input cluster attribute values:", func() {
+
+			// Process input cluster.yaml file, this should process input cluster.yaml file
+			// and update the environment with legacy name and values
+			// most of cluster.yaml attributes are mapped to legacy variable for more look this - constants.ClusterToLegacyVariablesMapVsphere
+			IsInputFileClusterClassBased, err := ctl.processWorkloadClusterInputFile(&options, false)
+			Expect(IsInputFileClusterClassBased).Should(BeTrue())
+			Expect(err).To(BeNil())
+
+			// process input file and get map, which has all attribute's path and its values
+			inputVariablesMap := getInputAttributesMap(&ctl, options.ClusterConfigFile)
+
+			// validate input Cluster Object yaml file attributes values with corresponding legacy variable values in environment, both should be same, as we have already updated the environment with Cluster Object attribute values.
+			validateFileInputAttributeValuesWithEnvironmentValues(&ctl, inputVariablesMap, constants.ClusterAttributesToLegacyVariablesMapVsphere)
+
+			// checking manually for some variables mapping values
+			mappedVal, _ := ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableClusterName)
+			Expect("vsphere-workload-cluster1").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableNamespace)
+			Expect("namespace-test1").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for "spec.clusterNetwork.pods.cidrBlocks":     ConfigVariableClusterCIDR
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableClusterCIDR)
+			Expect("10.10.10.10/18").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for "spec.topology.controlPlane.replicas": ConfigVariableControlPlaneMachineCount,
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableControlPlaneMachineCount)
+			Expect("5").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for "spec.topology.variables.network.proxy.httpsProxy": TKGHTTPSProxy
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.TKGHTTPSProxy)
+			Expect("http://10.0.200.100").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for "spec.topology.variables.imageRepository.tlsCertificateValidation": ConfigVariableCustomImageRepositorySkipTLSVerify
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableCustomImageRepositorySkipTLSVerify)
+			Expect("true").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for "spec.topology.variables.trust.proxy":           TKGProxyCACert  TKG_PROXY_CA_CERT
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.TKGProxyCACert)
+			Expect("LS0tLS=").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for "spec.topology.variables.apiServerPort": ConfigVariableClusterAPIServerPort  CLUSTER_API_SERVER_PORT
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableClusterAPIServerPort)
+			Expect("443").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for "spec.topology.variables.apiServerEndpoint":      ConfigVariableVsphereControlPlaneEndpoint, VSPHERE_CONTROL_PLANE_ENDPOINT
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableVsphereControlPlaneEndpoint)
+			Expect("http://10.0.200.101").To(Equal(fmt.Sprintf("%v", mappedVal)))
+			// check that cluster options also updated
+			Expect("http://10.0.200.101").To(Equal(options.VsphereControlPlaneEndpoint))
+
+			// check value for "spec.topology.variables.controlPlane.network.nameservers"
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableControlPlaneNodeNameservers)
+			Expect("100.64.0.0").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			//  check value for "spec.topology.variables.controlPlane.machine.numCPUs
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableVsphereCPNumCpus)
+			Expect("2").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			//  check value for "spec.topology.variables.worker.machine.memoryMiB" ConfigVariableVsphereWorkerMemMib
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableVsphereWorkerMemMib)
+			Expect("16384").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for "spec.topology.workers.machineDeployments.2.failureDomain"  - ConfigVariableVsphereAz2
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableVsphereAz2)
+			Expect("us-east-1c").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+		})
+	})
+})
+
+var _ = Describe("Unit tests for - (Azure) - cluster_azure.yaml as input file for 'tanzu cluster create -f cluster_azure.yaml' use case", func() {
+	var (
+		ctl       tkgctl
+		tkgClient = &fakes.Client{}
+		bomClient = &fakes.TKGConfigBomClient{}
+		options   CreateClusterOptions
+	)
+	JustBeforeEach(func() {
+		tkgConfigReaderWriter, _ := tkgconfigreaderwriter.NewReaderWriterFromConfigFile(configFilePath, configFilePath)
+		ctl = tkgctl{
+			configDir:              testingDir,
+			tkgClient:              tkgClient,
+			tkgConfigReaderWriter:  tkgConfigReaderWriter,
+			tkgConfigUpdaterClient: tkgconfigupdater.New(testingDir, nil, tkgConfigReaderWriter),
+			tkgBomClient:           bomClient,
+		}
+		tkgClient.IsFeatureActivatedReturns(true)
+	})
+	Context("When inpput file is valid Cluster Class, plan devcc:", func() {
+		BeforeEach(func() {
+			options = CreateClusterOptions{
+				ClusterName:            "test-cluster",
+				Plan:                   "dev",
+				InfrastructureProvider: "",
+				Namespace:              "",
+				GenerateOnly:           false,
+				TkrVersion:             fakeTKRVersion,
+				SkipPrompt:             true,
+				Edition:                "tkg",
+				ClusterConfigFile:      classInputFileAzure,
+			}
+		})
+		It("Environment should be updated with legacy variables with input cluster attribute values:", func() {
+
+			// Process input cluster yaml file, this should process input cluster yaml file
+			// and update the environment with legacy name and values
+			// most of cluster yaml attributes are mapped to legacy variable for more look this - constants.ClusterToLegacyVariablesMapAzure
+			IsInputFileClusterClassBased, err := ctl.processWorkloadClusterInputFile(&options, false)
+			Expect(IsInputFileClusterClassBased).Should(BeTrue())
+			Expect(err).To(BeNil())
+
+			// process input file and get map, which has all attribute's path and its values
+			inputVariablesMap := getInputAttributesMap(&ctl, options.ClusterConfigFile)
+
+			// validate input Cluster Object yaml file attributes values with corresponding legacy variables values in environment, both should be same, as we have already updated the environment with Cluster Object attribute values.
+			validateFileInputAttributeValuesWithEnvironmentValues(&ctl, inputVariablesMap, constants.ClusterAttributesToLegacyVariablesMapAzure)
+
+			// checking manually for some variables mapping values
+			mappedVal, _ := ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableClusterName)
+			Expect("azure-workload-cluster1").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// checking manually for some variables mapping values
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableNamespace)
+			Expect("namespace-test1").To(Equal(fmt.Sprintf("%v", mappedVal)))
+			//Check that cluster options also updated
+			Expect("namespace-test1").To(Equal(options.Namespace))
+			Expect("azure").To(Equal(options.InfrastructureProvider))
+
+			//  check value for "spec.clusterNetwork.services.cidrBlocks": ConfigVariableServiceCIDR,
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableServiceCIDR)
+			Expect("10.10.10.10/16").To(Equal(fmt.Sprintf("%v", mappedVal)))
+
+			// check value for "spec.topology.workers.machineDeployments.2.failureDomain"  - ConfigVariableAzureAZ2
+			mappedVal, _ = ctl.TKGConfigReaderWriter().Get(constants.ConfigVariableAzureAZ2)
+			Expect("us-east-1c").To(Equal(fmt.Sprintf("%v", mappedVal)))
+		})
+	})
+})
+
+var _ = Describe("Unit tests for feature flag (config.FeatureFlagPackageBasedLCM) and featureGate for clusterclass - TKGS : Vsphere provider, devcc:", func() {
 	var (
 		options   CreateClusterOptions
 		tkgClient *fakes.Client
@@ -337,7 +564,7 @@ var _ = Describe("Unit tests for feature flag (config.FeatureFlagPackageBasedLCM
 		BeforeEach(func() {
 			options = CreateClusterOptions{
 				ClusterName:            "test-cluster",
-				Plan:                   "dev",
+				Plan:                   "devcc",
 				InfrastructureProvider: "",
 				Namespace:              "",
 				GenerateOnly:           false,
@@ -346,11 +573,11 @@ var _ = Describe("Unit tests for feature flag (config.FeatureFlagPackageBasedLCM
 				Edition:                "tkg",
 			}
 		})
-		It("positive case, feature flag (config.FeatureFlagPackageBasedLCM) enabled, clusterclass featuregate enabled, and its TKGS cluster", func() {
-			kubeConfigPath := getConfigFilePath()
+		It("When feature flag (config.FeatureFlagPackageBasedLCM) enabled, input Cluster file is processed:", func() {
+			kubeConfigPath := classInputFileVsphere
 			regionContext := region.RegionContext{
 				ContextName:    "queen-anne-context",
-				SourceFilePath: kubeConfigPath,
+				SourceFilePath: classInputFileVsphere,
 			}
 
 			tkgClient = &fakes.Client{}
@@ -358,7 +585,7 @@ var _ = Describe("Unit tests for feature flag (config.FeatureFlagPackageBasedLCM
 			tkgClient.GetCurrentRegionContextReturns(regionContext, nil)
 			tkgClient.IsFeatureActivatedReturns(true)
 			tkgClient.CreateClusterReturnsOnCall(0, false, nil)
-			options.ClusterConfigFile = ccConfigFilePath
+			options.ClusterConfigFile = classInputFileVsphere
 			tkgConfigReaderWriter, _ := tkgconfigreaderwriter.NewReaderWriterFromConfigFile(configFilePath, configFilePath)
 			fg := &fakes.FakeFeatureGateHelper{}
 			fg.FeatureActivatedInNamespaceReturns(true, nil)
@@ -370,6 +597,7 @@ var _ = Describe("Unit tests for feature flag (config.FeatureFlagPackageBasedLCM
 				tkgConfigUpdaterClient: tkgconfigupdater.New(testingDir, nil, tkgConfigReaderWriter),
 				featureGateHelper:      fg,
 			}
+			tkgConfigReaderWriter.Set(constants.ConfigVariableClusterPlan, "dev")
 			_ = tkgctlClient.CreateCluster(options)
 			// Make sure call completed till end
 			c := tkgClient.CreateClusterCallCount()
@@ -379,9 +607,9 @@ var _ = Describe("Unit tests for feature flag (config.FeatureFlagPackageBasedLCM
 			Expect(1).To(Equal(pc))
 			// Make sure its ClusterClass use case.
 			cname, _ := tkgctlClient.tkgConfigReaderWriter.Get("CLUSTER_NAME")
-			Expect(cname).To(Equal("wcc2"))
+			Expect(cname).To(Equal("vsphere-workload-cluster1"))
 		})
-		It("clusterclass feature flag 'config.FeatureFlagPackageBasedLCM' not enabled", func() {
+		It("When feature flag (config.FeatureFlagPackageBasedLCM) not enabled, input Cluster file is not processed:", func() {
 			kubeConfigPath := getConfigFilePath()
 			regionContext := region.RegionContext{
 				ContextName:    "queen-anne-context",
@@ -393,7 +621,7 @@ var _ = Describe("Unit tests for feature flag (config.FeatureFlagPackageBasedLCM
 			tkgClient.GetCurrentRegionContextReturns(regionContext, nil)
 			tkgClient.IsFeatureActivatedReturns(false)
 			tkgClient.CreateClusterReturnsOnCall(0, false, nil)
-			options.ClusterConfigFile = ccConfigFilePath
+			options.ClusterConfigFile = classInputFileAzure
 			tkgConfigReaderWriter, _ := tkgconfigreaderwriter.NewReaderWriterFromConfigFile(configFilePath, configFilePath)
 			fg := &fakes.FakeFeatureGateHelper{}
 			fg.FeatureActivatedInNamespaceReturns(true, nil)
@@ -412,75 +640,124 @@ var _ = Describe("Unit tests for feature flag (config.FeatureFlagPackageBasedLCM
 			// Make sure its TKGs system.
 			pc := tkgClient.IsPacificManagementClusterCallCount()
 			Expect(1).To(Equal(pc))
-			// As feature flag (config.FeatureFlagPackageBasedLCM) is not enabled, the input ccluster1_clusterOnly.yaml file not processed,
+			// As feature flag (config.FeatureFlagPackageBasedLCM) is not enabled, the input cluster1_clusterOnly.yaml file not processed,
 			// so cname is empty only.
 			cname, _ := tkgctlClient.tkgConfigReaderWriter.Get("CLUSTER_NAME")
 			Expect(cname).To(Equal(""))
 		})
-		It("Feature 'clusterclass' is disabled in featuregate", func() {
-			kubeConfigPath := getConfigFilePath()
-			regionContext := region.RegionContext{
-				ContextName:    "queen-anne-context",
-				SourceFilePath: kubeConfigPath,
-			}
+		/*
+			TODO: (chandrareddyp) enable this test cases once the TKGS fixes feature gate issues
+			It("When Feature 'clusterclass' is disabled in featuregate, return error", func() {
+				kubeConfigPath := getConfigFilePath()
+				regionContext := region.RegionContext{
+					ContextName:    "queen-anne-context",
+					SourceFilePath: kubeConfigPath,
+				}
+
+				tkgClient = &fakes.Client{}
+				tkgClient.IsPacificManagementClusterReturnsOnCall(0, true, nil)
+				tkgClient.GetCurrentRegionContextReturns(regionContext, nil)
+				tkgClient.IsFeatureActivatedReturns(true)
+				tkgClient.CreateClusterReturnsOnCall(0, false, nil)
+				options.ClusterConfigFile = classInputFileAzure
+				tkgConfigReaderWriter, _ := tkgconfigreaderwriter.NewReaderWriterFromConfigFile(configFilePath, configFilePath)
+				fg := &fakes.FakeFeatureGateHelper{}
+				fg.FeatureActivatedInNamespaceReturns(false, nil)
+				tkgctlClient := &tkgctl{
+					configDir:              testingDir,
+					tkgClient:              tkgClient,
+					kubeconfig:             kubeConfigPath,
+					tkgConfigReaderWriter:  tkgConfigReaderWriter,
+					tkgConfigUpdaterClient: tkgconfigupdater.New(testingDir, nil, tkgConfigReaderWriter),
+					featureGateHelper:      fg,
+				}
+				// feature flag (config.FeatureFlagPackageBasedLCM) activated, its clusterclass input file, but "clusterclass" feature in FeatureGate is disabled, so throws error
+				err := tkgctlClient.CreateCluster(options)
+				expectedErrMsg := "vSphere with Tanzu environment detected, however, the feature 'clusterclass' is not activated in 'vmware-system-capw' namespace "
+				Expect(err.Error()).To(ContainSubstring(expectedErrMsg))
+			})
+
+
+			It("When featuregate api it self throws error", func() {
+				kubeConfigPath := getConfigFilePath()
+				regionContext := region.RegionContext{
+					ContextName:    "queen-anne-context",
+					SourceFilePath: kubeConfigPath,
+				}
+
+				tkgClient = &fakes.Client{}
+				tkgClient.IsPacificManagementClusterReturnsOnCall(0, true, nil)
+				tkgClient.GetCurrentRegionContextReturns(regionContext, nil)
+				tkgClient.IsFeatureActivatedReturns(true)
+				tkgClient.CreateClusterReturnsOnCall(0, false, nil)
+				options.ClusterConfigFile = classInputFileAzure
+				tkgConfigReaderWriter, _ := tkgconfigreaderwriter.NewReaderWriterFromConfigFile(configFilePath, configFilePath)
+				fg := &fakes.FakeFeatureGateHelper{}
+				errorMsg := "error while feature status in featuregate"
+				fg.FeatureActivatedInNamespaceReturns(true, fmt.Errorf(errorMsg))
+				tkgctlClient := &tkgctl{
+					configDir:              testingDir,
+					tkgClient:              tkgClient,
+					kubeconfig:             kubeConfigPath,
+					tkgConfigReaderWriter:  tkgConfigReaderWriter,
+					tkgConfigUpdaterClient: tkgconfigupdater.New(testingDir, nil, tkgConfigReaderWriter),
+					featureGateHelper:      fg,
+				}
+				// feature flag (config.FeatureFlagPackageBasedLCM) activated, its clusterclass config input file, but "clusterclass" feature in FeatureGate is enabled,
+				// but throws error for the FeatureGate api, so we expect error here.
+				err := tkgctlClient.CreateCluster(options)
+				// as FeatureGate api throws error, we expect error.
+				Expect(err.Error()).To(ContainSubstring(errorMsg))
+			})
+		*/
+	})
+})
 
-			tkgClient = &fakes.Client{}
-			tkgClient.IsPacificManagementClusterReturnsOnCall(0, true, nil)
-			tkgClient.GetCurrentRegionContextReturns(regionContext, nil)
-			tkgClient.IsFeatureActivatedReturns(true)
-			tkgClient.CreateClusterReturnsOnCall(0, false, nil)
-			options.ClusterConfigFile = ccConfigFilePath
-			tkgConfigReaderWriter, _ := tkgconfigreaderwriter.NewReaderWriterFromConfigFile(configFilePath, configFilePath)
-			fg := &fakes.FakeFeatureGateHelper{}
-			fg.FeatureActivatedInNamespaceReturns(false, nil)
-			tkgctlClient := &tkgctl{
-				configDir:              testingDir,
-				tkgClient:              tkgClient,
-				kubeconfig:             kubeConfigPath,
-				tkgConfigReaderWriter:  tkgConfigReaderWriter,
-				tkgConfigUpdaterClient: tkgconfigupdater.New(testingDir, nil, tkgConfigReaderWriter),
-				featureGateHelper:      fg,
-			}
-			// feature flag (config.FeatureFlagPackageBasedLCM) activated, its clusterclass input file, but "clusterclass" feature in FeatureGate is disabled, so throws error
-			err := tkgctlClient.CreateCluster(options)
-			expectedErrMsg := "vSphere with Tanzu environment detected, however, the feature 'clusterclass' is not activated in 'vmware-system-capw' namespace "
-			Expect(err.Error()).To(ContainSubstring(expectedErrMsg))
-		})
+// getInputAttributesMap process input Cluster Object yaml file and returns a map which has all attributes from the input file and its values
+func getInputAttributesMap(ctl *tkgctl, inputFile string) map[string]interface{} {
+	// to make sure input cluster attributes values are updated with legacy variables in environment (tkgctl.TKGConfigReaderWriter())
+	// Processing the input cluster yaml file with the existing util api, and expecting Cluster YAML object,
+	// from the Cluster YAML object, map attributes path with values, and update Map variablesMap.
+	_, clusterObj, _ := ctl.checkIfInputFileIsClusterClassBased(inputFile)
+	inputVariablesMap := make(map[string]interface{})
+	inputVariablesMap["metadata.name"] = clusterObj.GetName()
+	inputVariablesMap["metadata.namespace"] = clusterObj.GetNamespace()
+	spec := clusterObj.Object[constants.SPEC].(map[string]interface{})
+	err := processYamlObjectAndAddToMap(spec, constants.SPEC, inputVariablesMap)
+	Expect(err).To(BeNil())
+	return inputVariablesMap
+}
 
-		It("featuregate api throws error", func() {
-			kubeConfigPath := getConfigFilePath()
-			regionContext := region.RegionContext{
-				ContextName:    "queen-anne-context",
-				SourceFilePath: kubeConfigPath,
+// validateFileInputAttributeValuesWithEnvironmentValues takes the Cluster Object yaml file input variable map and checks its values in the environment, both should be same.
+func validateFileInputAttributeValuesWithEnvironmentValues(ctl *tkgctl, inputVariablesMap map[string]interface{}, clusterAttributesToLegacyVariablesMap map[string]string) {
+	// take  legacy variable name for every attribute in cluster input file,
+	// then check the value of legacy variable in environment, with value of the same from the input file
+	// both should match.
+	for key := range inputVariablesMap {
+		if inputValue := inputVariablesMap[key]; inputValue != nil {
+			legacyNameForClusterObjectInputVariable, ok := clusterAttributesToLegacyVariablesMap[key]
+			if ok && legacyNameForClusterObjectInputVariable != "" {
+				mappedVal, _ := ctl.TKGConfigReaderWriter().Get(legacyNameForClusterObjectInputVariable)
+				Expect(fmt.Sprintf("%v", mappedVal)).To(Equal(fmt.Sprintf("%v", inputValue)))
 			}
+		}
+	}
+}
 
-			tkgClient = &fakes.Client{}
-			tkgClient.IsPacificManagementClusterReturnsOnCall(0, true, nil)
-			tkgClient.GetCurrentRegionContextReturns(regionContext, nil)
-			tkgClient.IsFeatureActivatedReturns(true)
-			tkgClient.CreateClusterReturnsOnCall(0, false, nil)
-			options.ClusterConfigFile = ccConfigFilePath
-			tkgConfigReaderWriter, _ := tkgconfigreaderwriter.NewReaderWriterFromConfigFile(configFilePath, configFilePath)
-			fg := &fakes.FakeFeatureGateHelper{}
-			errorMsg := "error while feature status in featuregate"
-			fg.FeatureActivatedInNamespaceReturns(true, fmt.Errorf(errorMsg))
-			tkgctlClient := &tkgctl{
-				configDir:              testingDir,
-				tkgClient:              tkgClient,
-				kubeconfig:             kubeConfigPath,
-				tkgConfigReaderWriter:  tkgConfigReaderWriter,
-				tkgConfigUpdaterClient: tkgconfigupdater.New(testingDir, nil, tkgConfigReaderWriter),
-				featureGateHelper:      fg,
-			}
-			// feature flag (config.FeatureFlagPackageBasedLCM) activated, its clusterclass config input file, but "clusterclass" feature in FeatureGate is enabled,
-			// but throws errro for the FeatureGate api, so we expecte error here.
-			err := tkgctlClient.CreateCluster(options)
-			fmt.Println(err.Error())
-			// as FeatureGate api throws error, we expecte error.
-			Expect(err.Error()).To(ContainSubstring(errorMsg))
-		})
-	})
-})
+// updateLowerPrecedenceVariablesWithHigherPrecedenceVariablesValues, updates lower precedence variables with higher precedence variables values.
+func updateLowerPrecedenceVariablesWithHigherPrecedenceVariablesValues(inputVariablesMap map[string]interface{}) {
+	// below logic, takes higher precedence attribute path and its lower precedence path,
+	// check if lower precedence path has value if so overrides with higher precedence path value.
+	for higherPrecedenceKey := range constants.ClusterAttributesHigherPrecedenceToLowerMap {
+		_, ok1 := constants.ClusterAttributesToLegacyVariablesMapAws[higherPrecedenceKey]
+		value, ok2 := inputVariablesMap[higherPrecedenceKey]
+		if ok1 && ok2 {
+			lowerPrecedenceAttribute := constants.ClusterAttributesHigherPrecedenceToLowerMap[higherPrecedenceKey]
+			// lower precedence attribute value should be the value of higher
+			inputVariablesMap[lowerPrecedenceAttribute] = fmt.Sprintf("%v", value)
+		}
+	}
+}
 
 func getConfigFilePath() string {
 	filename := "config1.yaml"
diff --git a/pkg/v1/tkg/tkgctl/helpers_test.go b/pkg/v1/tkg/tkgctl/helpers_test.go
new file mode 100644
index 0000000000..a7c920988f
--- /dev/null
+++ b/pkg/v1/tkg/tkgctl/helpers_test.go
@@ -0,0 +1,213 @@
+// Copyright 2021 VMware, Inc. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package tkgctl
+
+import (
+	"fmt"
+	"strings"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/vmware-tanzu/tanzu-framework/pkg/v1/tkg/constants"
+)
+
+var _ = Describe("Cluster Class - IP Family Validation related test cases: ", func() {
+	var cidrsIpv6Ipv4 string
+	var cidrsIpv4 string
+	var cidrsIpv4Ipv6 string
+	BeforeEach(func() {
+		cidrsIpv6Ipv4 = "2002::1234:abcd:ffff:c0a8:101/64,100.64.0.0/18"
+		cidrsIpv4 = "100.96.0.0/12,100.64.0.0/16"
+		cidrsIpv4Ipv6 = "100.64.0.0/18,2002::1234:abcd:ffff:c0a8:101/64"
+	})
+	Context("GetIPFamilyForGivenCIDRs related test cases", func() {
+		var isIPV6Primary bool
+		When("When isIPV6Primary is true ", func() {
+			BeforeEach(func() {
+				isIPV6Primary = true
+			})
+			It("first cidr do not have ipv6, should get error:", func() {
+				_, err := GetIPFamilyForGivenCIDRs(strings.Split(cidrsIpv4, ","), isIPV6Primary)
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring(fmt.Sprintf(errMessageIPv6EnabledCIDRHasNoIPv6, strings.Split(cidrsIpv4, ","))))
+			})
+			It("first cidr is ipv4 not ipv6, should get error:", func() {
+				_, err := GetIPFamilyForGivenCIDRs(strings.Split(cidrsIpv4Ipv6, ","), isIPV6Primary)
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring(fmt.Sprintf(errMessageIPv6EnabledCIDRHasNoIPv6, strings.Split(cidrsIpv4Ipv6, ","))))
+			})
+			It("first cidr is ipv6, should expect ip family as DualStackPrimaryIPv6Family", func() {
+				family, err := GetIPFamilyForGivenCIDRs(strings.Split(cidrsIpv6Ipv4, ","), isIPV6Primary)
+				Expect(err).To(BeNil())
+				Expect(constants.DualStackPrimaryIPv6Family).To(Equal(family))
+			})
+			It("both cidr is ipv6, should expect IP Family as ipv6", func() {
+				cidr := "2002::1234:abcd:ffff:c0a8:101/64,2002::1234:abcd:ffff:c0a8:101/24"
+				family, err := GetIPFamilyForGivenCIDRs(strings.Split(cidr, ","), isIPV6Primary)
+				Expect(err).To(BeNil())
+				Expect(constants.IPv6Family).To(Equal(family))
+			})
+		})
+
+		When("When isIPV6Primary is false", func() {
+			BeforeEach(func() {
+				isIPV6Primary = false
+			})
+
+			It("first cidr is ipv6, expect family as DualStackPrimaryIPv4Family", func() {
+				family, err := GetIPFamilyForGivenCIDRs(strings.Split(cidrsIpv6Ipv4, ","), isIPV6Primary)
+				Expect(err).To(BeNil())
+				Expect(constants.DualStackPrimaryIPv4Family).To(Equal(family))
+			})
+			It("second cidr is ipv6, expect family as DualStackPrimaryIPv4Family", func() {
+				family, err := GetIPFamilyForGivenCIDRs(strings.Split(cidrsIpv4Ipv6, ","), isIPV6Primary)
+				Expect(err).To(BeNil())
+				Expect(constants.DualStackPrimaryIPv4Family).To(Equal(family))
+			})
+			It("first ipv6 value, should return error", func() {
+				cidrsIpv6Incorrect := "inCorrect2002::1234:abcd:ffff:c0a8:101/64,2002::1234:abcd:ffff:c0a8:101/24"
+				_, err := GetIPFamilyForGivenCIDRs(strings.Split(cidrsIpv6Incorrect, ","), isIPV6Primary)
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("could not parse CIDR"))
+			})
+			It("second ipv6 value, should return error", func() {
+				cidrsIpv6Incorrect := "2002::1234:abcd:ffff:c0a8:101/64,IN-CORREC-2002::1234:abcd:ffff:c0a8:101/24"
+				_, err := GetIPFamilyForGivenCIDRs(strings.Split(cidrsIpv6Incorrect, ","), isIPV6Primary)
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("could not parse CIDR"))
+			})
+			It("incorrect cidr - first ipv4 value", func() {
+				cidrsIncorrectFirstValue := "10055.64.0.0/18,100.64.0.0/18"
+				_, err := GetIPFamilyForGivenCIDRs(strings.Split(cidrsIncorrectFirstValue, ","), isIPV6Primary)
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("could not parse CIDR"))
+			})
+			It("When incorrect cidr - second ipv4 value, should return error", func() {
+				cidrsIncorrectSecondValue := "100.64.0.0/18,10044.64.0.0/18"
+				_, err := GetIPFamilyForGivenCIDRs(strings.Split(cidrsIncorrectSecondValue, ","), isIPV6Primary)
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("could not parse CIDR"))
+			})
+			It("When correct cidr - both are ipv4, should get ipv4 as ip family", func() {
+				family, err := GetIPFamilyForGivenCIDRs(strings.Split(cidrsIpv4, ","), isIPV6Primary)
+				Expect(err).To(BeNil())
+				Expect(constants.IPv4Family).To(Equal(family))
+			})
+			It("When correct cidr - only one ipv4 value, ipv4 as ip family", func() {
+				cidrSingleValue := "100.64.0.0/18"
+				family, err := GetIPFamilyForGivenCIDRs(strings.Split(cidrSingleValue, ","), isIPV6Primary)
+				Expect(err).To(BeNil())
+				Expect(constants.IPv4Family).To(Equal(family))
+			})
+			It("When correct cidrs - too many values - three ipv4 values, return error:", func() {
+				cidrsThreeValues := "100.64.0.0/18,101.64.0.0/18,102.64.0.0/18"
+				_, err := GetIPFamilyForGivenCIDRs(strings.Split(cidrsThreeValues, ","), isIPV6Primary)
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("too many CIDRs specified"))
+			})
+		})
+	})
+
+	Context("stringArrayToStringWithCommaSeparatedElements test cases ", func() {
+		It("When CIDR values as input, get array of CIDR values:", func() {
+			cidr := "[100.96.0.0/12 100.64.0.0/16]"
+			output := stringArrayToStringWithCommaSeparatedElements(cidr)
+			Expect(output).To(Equal(cidrsIpv4))
+		})
+		It("When string values, get array of string values:", func() {
+			cidr := "[str1 str2]"
+			output := stringArrayToStringWithCommaSeparatedElements(cidr)
+			Expect(output).To(Equal("str1,str2"))
+		})
+	})
+
+	Context("Test GetIPFamilyForGivenClusterNetworkCIDRs for given clusterNetwork's pods CIDRs and service CIDRs", func() {
+		var isIPV6Primary bool
+		When("When isIPV6Primary is true:", func() {
+			BeforeEach(func() {
+				isIPV6Primary = true
+			})
+
+			It("all are ipv4, returns error ", func() {
+				podCIDR := cidrsIpv4
+				serviceCIDR := cidrsIpv4
+				_, err := GetIPFamilyForGivenClusterNetworkCIDRs(podCIDR, serviceCIDR, isIPV6Primary)
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("the isIPV6Primary: true, but the first value in CIDRs"))
+			})
+			It("ipv6 and ipv4, expect DualStackPrimaryIPv6Family", func() {
+				podCIDR := cidrsIpv6Ipv4
+				serviceCIDR := cidrsIpv6Ipv4
+				family, err := GetIPFamilyForGivenClusterNetworkCIDRs(podCIDR, serviceCIDR, isIPV6Primary)
+				Expect(err).To(BeNil())
+				Expect(constants.DualStackPrimaryIPv6Family).To(Equal(family))
+			})
+		})
+
+		When("When isIPV6Primary is false:", func() {
+			BeforeEach(func() {
+				isIPV6Primary = false
+			})
+			It("both ipv4 values, get ipv4 as IP family:", func() {
+				podCIDR := cidrsIpv4
+				serviceCIDR := cidrsIpv4
+				family, err := GetIPFamilyForGivenClusterNetworkCIDRs(podCIDR, serviceCIDR, isIPV6Primary)
+				Expect(err).To(BeNil())
+				Expect(constants.IPv4Family).To(Equal(family))
+			})
+			It("both are ipv6,ipv4, should return ipv4,ipv6 ", func() {
+				podCIDR := cidrsIpv6Ipv4
+				serviceCIDR := cidrsIpv6Ipv4
+				family, err := GetIPFamilyForGivenClusterNetworkCIDRs(podCIDR, serviceCIDR, isIPV6Primary)
+				Expect(err).To(BeNil())
+				Expect(constants.DualStackPrimaryIPv4Family).To(Equal(family))
+			})
+			It("different IP Families, podCIDR has ipv6 and ipv4, service cidr has only ipv4 type:  so return error", func() {
+				podCIDR := cidrsIpv6Ipv4
+				serviceCIDR := cidrsIpv4
+				_, err := GetIPFamilyForGivenClusterNetworkCIDRs(podCIDR, serviceCIDR, isIPV6Primary)
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("both are not same IP Families"))
+			})
+		})
+	})
+
+	Context("Test cases for getProviderNameFromTopologyClassName  - validate value of spec.topology.class attribute ", func() {
+		When("When correct value is provided:", func() {
+			It("aws provider, return aws as provider:", func() {
+				cidr := "tkg-aws-default"
+				provider, err := getProviderNameFromTopologyClassName(cidr)
+				Expect(provider).To(Equal("aws"))
+				Expect(err).To(BeNil())
+			})
+			It("azure provider, return azure as provider:", func() {
+				cidr := "tkg-azure-default"
+				provider, err := getProviderNameFromTopologyClassName(cidr)
+				Expect(provider).To(Equal("azure"))
+				Expect(err).To(BeNil())
+			})
+			It("Vsphere provider, return Vsphere as provider:", func() {
+				cidr := "tkg-vsphere-default"
+				provider, err := getProviderNameFromTopologyClassName(cidr)
+				Expect(provider).To(Equal("vsphere"))
+				Expect(err).To(BeNil())
+			})
+		})
+		When("When incorrect or empty value provided:", func() {
+			It("empty value, return error", func() {
+				cidr := ""
+				_, err := getProviderNameFromTopologyClassName(cidr)
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring(constants.TopologyClassIncorrectValueErrMsg))
+			})
+			It("incorrect value, return error", func() {
+				cidr := "tkg-not-default"
+				_, err := getProviderNameFromTopologyClassName(cidr)
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring(constants.TopologyClassIncorrectValueErrMsg))
+			})
+		})
+	})
+})
diff --git a/pkg/v1/tkg/utils/converter_test.go b/pkg/v1/tkg/utils/converter_test.go
new file mode 100644
index 0000000000..b86d6095c2
--- /dev/null
+++ b/pkg/v1/tkg/utils/converter_test.go
@@ -0,0 +1,51 @@
+// Copyright 2021 VMware, Inc. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package utils_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	. "github.com/vmware-tanzu/tanzu-framework/pkg/v1/tkg/utils"
+)
+
+var _ = Describe("Test Converter function Tests", func() {
+	Context("Test conversion with string types", func() {
+		It("Should return the expected output", func() {
+			Expect(Convert("abc")).To(Equal("abc"))
+			Expect(Convert("pqr")).To(Equal("pqr"))
+			Expect(Convert("a")).To(Equal("a"))
+		})
+	})
+
+	Context("Test conversion with int types", func() {
+		It("Should return the expected output", func() {
+			Expect(Convert("1")).To(Equal(uint64(1)))
+			Expect(Convert("22")).To(Equal(uint64(22)))
+			Expect(Convert("100")).To(Equal(uint64(100)))
+		})
+	})
+
+	Context("Test conversion with boolean types", func() {
+		It("Should return the expected output", func() {
+			Expect(Convert("true")).To(Equal(true))
+			Expect(Convert("false")).To(Equal(false))
+			Expect(Convert("True")).To(Equal(true))
+			Expect(Convert("False")).To(Equal(false))
+		})
+	})
+
+	Context("Test conversion with null value", func() {
+		It("Should return the expected output", func() {
+			Expect(Convert("null")).To(BeNil())
+		})
+	})
+
+	Context("Test conversion with float value", func() {
+		It("Should return the expected output", func() {
+			Expect(Convert("1.2")).To(Equal(1.2))
+			Expect(Convert("100.212")).To(Equal(100.212))
+		})
+	})
+})