选用何种Kubernetes数据结构统一表示Service、Deployment等基础对象？

I'm trying to find or define a generic Kubernetes data structure that can serve as a unified representation for objects like Service, Replication Controller, Deployment, StatefulSet, and DaemonSet.

The Kubernetes API has separate dedicated structures for each of these, but the closest generic types I've found so far are:

• ObjectMeta
• ObjectReference

However, I can't use either of these because my use case requires accessing the status field that's present in most workload objects. Specifically, I need to validate conditions such as:

• For replica-based workloads: replicas == readyReplicas == availableReplicas
• For other scenarios: Desired == Current == Available

Is there an existing generic structure in the Kubernetes API that includes these status fields, or what's the best approach to create such a unified representation?

Expert Answer #

Great question! Unfortunately, the Kubernetes API doesn’t provide a single built-in generic structure that combines metadata/references and the status fields across all those workload types and Service. Here are practical approaches to solve this:

1. Define a Custom Wrapper Struct #

Create your own Go struct that embeds common fields and includes a flexible status field to accommodate different object types:

import "k8s.io/apimachinery/pkg/apis/meta/v1"

type GenericK8sObject struct {
    v1.ObjectMeta `json:"metadata,omitempty"`
    Status        interface{} `json:"status,omitempty"`
}

You can unmarshal specific Kubernetes objects into this wrapper, then use type assertions to access status fields based on the object's Kind. For example:

// Assume deploymentObj is a fetched Deployment
var genericObj GenericK8sObject
if err := json.Unmarshal(deploymentObjJSON, &genericObj); err != nil {
    // Handle error
}

// Access Deployment-specific status fields
deploymentStatus, ok := genericObj.Status.(map[string]interface{})
if ok {
    replicas := deploymentStatus["replicas"].(int64)
    readyReplicas := deploymentStatus["readyReplicas"].(int64)
    // Validate your condition here
}

2. Use Client-Go's Dynamic Client #

The dynamic client lets you interact with any Kubernetes object without static type definitions. You can fetch objects as unstructured data and extract status fields directly:

import (
    "context"
    "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
    "k8s.io/apimachinery/pkg/runtime/schema"
    "k8s.io/client-go/dynamic"
)

// Initialize dynamic client (setup omitted for brevity)
gvr := schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "deployments"}
obj, err := dynamicClient.Resource(gvr).Namespace("default").Get(context.TODO(), "my-deployment", v1.GetOptions{})
if err != nil {
    // Handle error
}

// Extract status fields using unstructured map access
status := obj.UnstructuredContent()["status"].(map[string]interface{})
desired := status["replicas"].(int64)
current := status["updatedReplicas"].(int64)
available := status["availableReplicas"].(int64)

3. Build a Helper Utility for Status Checks #

Since each workload type has unique status fields (e.g., StatefulSets track currentRevision, DaemonSets use numberAvailable), create a helper function that switches on the object's Kind to standardize validation:

func IsObjectReady(obj *unstructured.Unstructured) bool {
    kind := obj.GetKind()
    status := obj.UnstructuredContent()["status"].(map[string]interface{})

    switch kind {
    case "Deployment":
        replicas := status["replicas"].(int64)
        ready := status["readyReplicas"].(int64)
        available := status["availableReplicas"].(int64)
        return replicas == ready && replicas == available
    case "DaemonSet":
        desired := status["desiredNumberScheduled"].(int64)
        current := status["currentNumberScheduled"].(int64)
        available := status["numberAvailable"].(int64)
        return desired == current && desired == available
    // Add cases for other object types
    default:
        return false
    }
}

内容的提问来源于stack exchange，提问作者Yashgiri Goswami