feat: Read instance city and workload from labels in CLI

The platform now stamps city-code, workload-name, workload-deployment-name,
and placement-name directly onto Instances at creation time. The CLI can
therefore resolve CITY/WORKLOAD/placement directly from those labels without
performing cross-object joins.

The prior approach keyed the WorkloadDeployment map on UID and looked up
instances via WorkloadDeploymentUIDLabel. That UID is the edge/Karmada WD UID,
which differs from the project-cluster WD UID, causing the join to fail across
federation planes and producing "unknown"/"orphaned" output.

The new label-first path reads CityCodeLabel, WorkloadNameLabel,
PlacementNameLabel, and WorkloadDeploymentNameLabel (name is identical across
all planes) before falling back to the WD Get/List join. A wdNameFromInstanceName
helper strips the trailing ordinal suffix from the Instance name as a last-resort
fallback for instances created before the labels existed.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: scotwells

api/v1alpha/labels.go

@@ -5,6 +5,26 @@ const (
 
 	WorkloadUIDLabel           = LabelNamespace + "/workload-uid"
 	WorkloadDeploymentUIDLabel = LabelNamespace + "/workload-deployment-uid"
+	// WorkloadDeploymentNameLabel carries the WorkloadDeployment name on each
+	// Instance. Unlike WorkloadDeploymentUIDLabel — which carries the
+	// edge/Karmada UID and therefore differs across federation planes —
+	// WorkloadDeploymentNameLabel is identical in the project cluster, Karmada,
+	// and on the edge, making it safe for cross-plane owner-ref resolution and
+	// CLI lookup.
+	WorkloadDeploymentNameLabel = LabelNamespace + "/workload-deployment-name"
 
 	InstanceIndexLabel = LabelNamespace + "/instance-index"
+
+	// CityCodeLabel carries the city code (e.g. "DFW") that the Instance is
+	// scheduled to. Stamped at creation time and immutable.
+	CityCodeLabel = LabelNamespace + "/city-code"
+
+	// WorkloadNameLabel carries the name of the Workload that owns this
+	// Instance. Stamped at creation time and immutable.
+	WorkloadNameLabel = LabelNamespace + "/workload-name"
+
+	// PlacementNameLabel carries the name of the placement entry within the
+	// Workload spec that produced this Instance. Stamped at creation time and
+	// immutable.
+	PlacementNameLabel = LabelNamespace + "/placement-name"
 )

internal/cmd/compute/instances/instances.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"sort"
 	"strings"
+	"unicode"
 
 	"github.com/spf13/cobra"
 	corev1 "k8s.io/api/core/v1"
@@ -118,15 +119,18 @@ func runList(cmd *cobra.Command, opts *listOptions) error {
 		return util.PrintYAML(cmd.OutOrStdout(), &instList)
 	}
 
-	// List deployments — build map deploymentUID → *WorkloadDeployment.
+	// List deployments — build map deploymentName → *WorkloadDeployment.
+	// Keyed by name (not UID) because the WorkloadDeploymentUIDLabel on an
+	// Instance carries the edge/Karmada WD UID, which differs from the
+	// project-cluster WD UID. The WD name is identical across all planes.
 	var deployList computev1alpha.WorkloadDeploymentList
 	if err := c.List(ctx, &deployList, client.InNamespace(util.ResourceNamespace)); err != nil {
 		return fmt.Errorf("listing deployments: %w", err)
 	}
 	deploymentMap := make(map[string]*computev1alpha.WorkloadDeployment, len(deployList.Items))
 	for i := range deployList.Items {
 		d := &deployList.Items[i]
-		deploymentMap[string(d.UID)] = d
+		deploymentMap[d.Name] = d
 	}
 
 	// List workloads — build map workloadUID → name.
@@ -142,18 +146,52 @@ func runList(cmd *cobra.Command, opts *listOptions) error {
 	// Build rows.
 	var rows []instanceRow
 	for _, inst := range instList.Items {
-		depUID := inst.Labels[computev1alpha.WorkloadDeploymentUIDLabel]
 		wlUID := inst.Labels[computev1alpha.WorkloadUIDLabel]
 
 		city := "unknown"
 		wlName := workloadMap[wlUID]
 		if wlName == "" {
 			wlName = "orphaned"
 		}
-		if dep, ok := deploymentMap[depUID]; ok {
-			city = dep.Spec.CityCode
-			if dep.Spec.WorkloadRef.Name != "" {
-				wlName = dep.Spec.WorkloadRef.Name
+
+		// Prefer self-describing labels stamped at creation time (fast path —
+		// no join needed). Fall back to the WorkloadDeployment join for older
+		// instances that predate the labels.
+		labelCity := inst.Labels[computev1alpha.CityCodeLabel]
+		labelWLName := inst.Labels[computev1alpha.WorkloadNameLabel]
+
+		if labelCity != "" && labelWLName != "" {
+			// Both labels present: no join needed.
+			city = labelCity
+			wlName = labelWLName
+		} else {
+			// At least one label absent — fall back to WorkloadDeployment lookup.
+			// Prefer the explicit WorkloadDeploymentNameLabel; fall back to
+			// deriving the WD name from the Instance name for existing instances
+			// that predate the label.
+			depName := inst.Labels[computev1alpha.WorkloadDeploymentNameLabel]
+			if depName == "" {
+				depName = wdNameFromInstanceName(inst.Name)
+			}
+			if dep, ok := deploymentMap[depName]; ok {
+				if labelCity != "" {
+					city = labelCity
+				} else {
+					city = dep.Spec.CityCode
+				}
+				if labelWLName != "" {
+					wlName = labelWLName
+				} else if dep.Spec.WorkloadRef.Name != "" {
+					wlName = dep.Spec.WorkloadRef.Name
+				}
+			} else {
+				// Deployment not found — use whatever labels we do have.
+				if labelCity != "" {
+					city = labelCity
+				}
+				if labelWLName != "" {
+					wlName = labelWLName
+				}
 			}
 		}
 
@@ -278,20 +316,61 @@ func runDescribe(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("getting instance: %w", err)
 	}
 
-	// Look up deployment.
-	deploymentUID := inst.Labels[computev1alpha.WorkloadDeploymentUIDLabel]
+	// Resolve CITY, WORKLOAD, and PLACEMENT. Prefer self-describing labels
+	// stamped at creation time (no join needed). Fall back to a
+	// WorkloadDeployment Get when any of the labels are absent, so that older
+	// instances that predate the stamp still resolve correctly.
 	workloadName := "orphaned"
 	city := "unknown"
 	placementName := ""
 
-	if deploymentUID != "" {
-		depSelector := labels.SelectorFromSet(labels.Set{computev1alpha.WorkloadDeploymentUIDLabel: deploymentUID})
-		var depList computev1alpha.WorkloadDeploymentList
-		if err := c.List(ctx, &depList, client.InNamespace(util.ResourceNamespace), client.MatchingLabelsSelector{Selector: depSelector}); err == nil && len(depList.Items) > 0 {
-			dep := depList.Items[0]
-			city = dep.Spec.CityCode
-			placementName = dep.Spec.PlacementName
-			workloadName = dep.Spec.WorkloadRef.Name
+	labelCity := inst.Labels[computev1alpha.CityCodeLabel]
+	labelWLName := inst.Labels[computev1alpha.WorkloadNameLabel]
+	labelPlacement := inst.Labels[computev1alpha.PlacementNameLabel]
+
+	if labelCity != "" && labelWLName != "" && labelPlacement != "" {
+		// All three labels present: no join needed.
+		city = labelCity
+		workloadName = labelWLName
+		placementName = labelPlacement
+	} else {
+		// At least one label absent — fall back to WorkloadDeployment Get.
+		// Prefer the WorkloadDeploymentNameLabel; fall back to deriving the WD
+		// name from the Instance name for existing instances that lack the label.
+		depName := inst.Labels[computev1alpha.WorkloadDeploymentNameLabel]
+		if depName == "" {
+			depName = wdNameFromInstanceName(inst.Name)
+		}
+		if depName != "" {
+			var dep computev1alpha.WorkloadDeployment
+			if err := c.Get(ctx, types.NamespacedName{Namespace: util.ResourceNamespace, Name: depName}, &dep); err == nil {
+				if labelCity != "" {
+					city = labelCity
+				} else {
+					city = dep.Spec.CityCode
+				}
+				if labelPlacement != "" {
+					placementName = labelPlacement
+				} else {
+					placementName = dep.Spec.PlacementName
+				}
+				if labelWLName != "" {
+					workloadName = labelWLName
+				} else {
+					workloadName = dep.Spec.WorkloadRef.Name
+				}
+			} else {
+				// WD Get failed — use whatever labels we do have.
+				if labelCity != "" {
+					city = labelCity
+				}
+				if labelWLName != "" {
+					workloadName = labelWLName
+				}
+				if labelPlacement != "" {
+					placementName = labelPlacement
+				}
+			}
 		}
 	}
 
@@ -385,6 +464,32 @@ func networkSummary(ifaces []computev1alpha.InstanceNetworkInterfaceStatus) stri
 	return fmt.Sprintf("External: %s  Internal: %s", extIP, intIP)
 }
 
+// wdNameFromInstanceName derives the WorkloadDeployment name from an Instance
+// name by stripping the trailing "-<ordinal>" suffix. Instance names follow the
+// convention "<wd-name>-<ordinal>" (e.g. "my-api-default-dfw-0" → "my-api-default-dfw").
+// This is used as a fallback when WorkloadDeploymentNameLabel is absent on older
+// instances that predate that label.
+//
+// If the name has no trailing numeric segment (not a standard instance name),
+// the original name is returned unchanged so callers can handle it gracefully.
+func wdNameFromInstanceName(instanceName string) string {
+	idx := strings.LastIndex(instanceName, "-")
+	if idx < 0 {
+		return instanceName
+	}
+	suffix := instanceName[idx+1:]
+	// The suffix must be entirely numeric digits to qualify as an ordinal.
+	for _, r := range suffix {
+		if !unicode.IsDigit(r) {
+			return instanceName
+		}
+	}
+	if suffix == "" {
+		return instanceName
+	}
+	return instanceName[:idx]
+}
+
 // formatEnvVar renders a single EnvVar for display.
 func formatEnvVar(e corev1.EnvVar) string {
 	if e.ValueFrom != nil {