Kubernetes Dynamic Client in Go: Building Flexible Controllers#

Introduction#

The Kubernetes dynamic client provides a powerful way to interact with any Kubernetes resource without compile-time type dependencies. This comprehensive guide explores advanced patterns for building flexible controllers, generic operators, and tools that work with custom resources dynamically.

Why Use Dynamic Client?#

🔄 Runtime Flexibility: Work with any resource discovered at runtime
📦 Zero Dependencies: No need to import CRD packages
🎯 Generic Operations: Build tools that work with any resource
🚀 Version Independence: Decouple from specific API versions
🔧 Discovery-Based: Leverage API discovery for dynamic behavior

Dynamic Client Architecture#

Client Comparison#

1
graph TB
2
    subgraph "Typed Client"
3
        TC[clientset.CoreV1.Pods] --> TP[Typed Pod Object]
4
        TC2[clientset.AppsV1.Deployments] --> TD[Typed Deployment]
5
    end
6

7
    subgraph "Dynamic Client"
8
        DC[dynamic.Resource] --> UN[Unstructured Object]
9
        DC --> GVR[GroupVersionResource]
10
        UN --> ANY[Any Resource Type]
11
    end
12

13
    subgraph "Use Cases"
14
        UC1[Known Resources] --> TC
15
        UC2[CRDs/Unknown Resources] --> DC
16
        UC3[Generic Tools] --> DC
17
        UC4[Runtime Discovery] --> DC
18
    end

Architecture Components#

Component	Purpose	Example
GVR	Resource identifier	`apps/v1/deployments`
Unstructured	Generic data container	`map[string]interface{}`
Discovery	API exploration	List available resources
RESTMapper	GVK to GVR mapping	Kind to Resource conversion
Informer	Event watching	Dynamic informer factory

Basic Operations#

1. Setting Up Dynamic Client#

1
package main
2

3
import (
4
    "context"
5
    "fmt"
6
    "log"
7
    "path/filepath"
8

9
    "k8s.io/apimachinery/pkg/api/meta"
10
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
11
    "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
12
    "k8s.io/apimachinery/pkg/runtime/schema"
13
    "k8s.io/client-go/discovery"
14
    "k8s.io/client-go/discovery/cached/memory"
15
    "k8s.io/client-go/dynamic"
16
    "k8s.io/client-go/restmapper"
17
    "k8s.io/client-go/tools/clientcmd"
18
    "k8s.io/client-go/util/homedir"
19
)
20

21
// DynamicClient wraps the Kubernetes dynamic client with helper methods
22
type DynamicClient struct {
23
    client    dynamic.Interface
24
    discovery discovery.DiscoveryInterface
25
    mapper    meta.RESTMapper
26
}
27

28
// NewDynamicClient creates a new dynamic client with discovery
29
func NewDynamicClient() (*DynamicClient, error) {
30
    // Build config
31
    var kubeconfig string
32
    if home := homedir.HomeDir(); home != "" {
33
        kubeconfig = filepath.Join(home, ".kube", "config")
34
    }
35

36
    config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
37
    if err != nil {
38
        // Try in-cluster config
39
        config, err = clientcmd.BuildConfigFromFlags("", "")
40
        if err != nil {
41
            return nil, err
42
        }
43
    }
44

45
    // Create dynamic client
46
    dynamicClient, err := dynamic.NewForConfig(config)
47
    if err != nil {
48
        return nil, err
49
    }
50

51
    // Create discovery client
52
    discoveryClient, err := discovery.NewDiscoveryClientForConfig(config)
53
    if err != nil {
54
        return nil, err
55
    }
56

57
    // Create REST mapper for resource discovery
58
    mapper := restmapper.NewDeferredDiscoveryRESTMapper(
59
        memory.NewMemCacheClient(discoveryClient),
60
    )
61

62
    return &DynamicClient{
63
        client:    dynamicClient,
64
        discovery: discoveryClient,
65
        mapper:    mapper,
66
    }, nil
67
}
68

69
// GetGVR converts a resource kind to GroupVersionResource
70
func (dc *DynamicClient) GetGVR(apiVersion, kind string) (schema.GroupVersionResource, error) {
71
    gv, err := schema.ParseGroupVersion(apiVersion)
72
    if err != nil {
73
        return schema.GroupVersionResource{}, err
74
    }
75

76
    gvk := gv.WithKind(kind)
77
    mapping, err := dc.mapper.RESTMapping(gvk.GroupKind(), gv.Version)
78
    if err != nil {
79
        return schema.GroupVersionResource{}, err
80
    }
81

82
    return mapping.Resource, nil
83
}

2. CRUD Operations#

1
// ResourceInterface provides CRUD operations for any resource
2
type ResourceInterface struct {
3
    dc        *DynamicClient
4
    gvr       schema.GroupVersionResource
5
    namespace string
6
}
7

8
// Resource returns an interface for the specified resource
9
func (dc *DynamicClient) Resource(gvr schema.GroupVersionResource) *ResourceInterface {
10
    return &ResourceInterface{
11
        dc:  dc,
12
        gvr: gvr,
13
    }
14
}
15

16
// Namespace sets the namespace for the resource operations
17
func (ri *ResourceInterface) Namespace(ns string) *ResourceInterface {
18
    ri.namespace = ns
19
    return ri
20
}
21

22
// Get retrieves a resource by name
23
func (ri *ResourceInterface) Get(ctx context.Context, name string) (*unstructured.Unstructured, error) {
24
    var resourceInterface dynamic.ResourceInterface
25

26
    if ri.namespace != "" {
27
        resourceInterface = ri.dc.client.Resource(ri.gvr).Namespace(ri.namespace)
28
    } else {
29
        resourceInterface = ri.dc.client.Resource(ri.gvr)
30
    }
31

32
    return resourceInterface.Get(ctx, name, metav1.GetOptions{})
33
}
34

35
// List retrieves all resources matching the label selector
36
func (ri *ResourceInterface) List(ctx context.Context, labelSelector string) (*unstructured.UnstructuredList, error) {
37
    var resourceInterface dynamic.ResourceInterface
38

39
    if ri.namespace != "" {
40
        resourceInterface = ri.dc.client.Resource(ri.gvr).Namespace(ri.namespace)
41
    } else {
42
        resourceInterface = ri.dc.client.Resource(ri.gvr)
43
    }
44

45
    return resourceInterface.List(ctx, metav1.ListOptions{
46
        LabelSelector: labelSelector,
47
    })
48
}
49

50
// Create creates a new resource
51
func (ri *ResourceInterface) Create(ctx context.Context, obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
52
    var resourceInterface dynamic.ResourceInterface
53

54
    if ri.namespace != "" {
55
        resourceInterface = ri.dc.client.Resource(ri.gvr).Namespace(ri.namespace)
56
    } else {
57
        resourceInterface = ri.dc.client.Resource(ri.gvr)
58
    }
59

60
    return resourceInterface.Create(ctx, obj, metav1.CreateOptions{})
61
}
62

63
// Update updates an existing resource
64
func (ri *ResourceInterface) Update(ctx context.Context, obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
65
    var resourceInterface dynamic.ResourceInterface
66

67
    if ri.namespace != "" {
68
        resourceInterface = ri.dc.client.Resource(ri.gvr).Namespace(ri.namespace)
69
    } else {
70
        resourceInterface = ri.dc.client.Resource(ri.gvr)
71
    }
72

73
    return resourceInterface.Update(ctx, obj, metav1.UpdateOptions{})
74
}
75

76
// Patch applies a patch to a resource
77
func (ri *ResourceInterface) Patch(ctx context.Context, name string, patchData []byte) (*unstructured.Unstructured, error) {
78
    var resourceInterface dynamic.ResourceInterface
79

80
    if ri.namespace != "" {
81
        resourceInterface = ri.dc.client.Resource(ri.gvr).Namespace(ri.namespace)
82
    } else {
83
        resourceInterface = ri.dc.client.Resource(ri.gvr)
84
    }
85

86
    return resourceInterface.Patch(ctx, name, types.MergePatchType, patchData, metav1.PatchOptions{})
87
}
88

89
// Delete removes a resource
90
func (ri *ResourceInterface) Delete(ctx context.Context, name string) error {
91
    var resourceInterface dynamic.ResourceInterface
92

93
    if ri.namespace != "" {
94
        resourceInterface = ri.dc.client.Resource(ri.gvr).Namespace(ri.namespace)
95
    } else {
96
        resourceInterface = ri.dc.client.Resource(ri.gvr)
97
    }
98

99
    return resourceInterface.Delete(ctx, name, metav1.DeleteOptions{})
100
}

3. Working with Unstructured Objects#

1
// UnstructuredHelper provides utilities for working with unstructured objects
2
type UnstructuredHelper struct{}
3

4
// GetString retrieves a string field from an unstructured object
5
func (uh *UnstructuredHelper) GetString(obj *unstructured.Unstructured, fields ...string) (string, error) {
6
    val, found, err := unstructured.NestedString(obj.Object, fields...)
7
    if err != nil {
8
        return "", err
9
    }
10
    if !found {
11
        return "", fmt.Errorf("field %v not found", fields)
12
    }
13
    return val, nil
14
}
15

16
// GetInt64 retrieves an int64 field from an unstructured object
17
func (uh *UnstructuredHelper) GetInt64(obj *unstructured.Unstructured, fields ...string) (int64, error) {
18
    val, found, err := unstructured.NestedInt64(obj.Object, fields...)
19
    if err != nil {
20
        return 0, err
21
    }
22
    if !found {
23
        return 0, fmt.Errorf("field %v not found", fields)
24
    }
25
    return val, nil
26
}
27

28
// GetSlice retrieves a slice field from an unstructured object
29
func (uh *UnstructuredHelper) GetSlice(obj *unstructured.Unstructured, fields ...string) ([]interface{}, error) {
30
    val, found, err := unstructured.NestedSlice(obj.Object, fields...)
31
    if err != nil {
32
        return nil, err
33
    }
34
    if !found {
35
        return nil, fmt.Errorf("field %v not found", fields)
36
    }
37
    return val, nil
38
}
39

40
// SetField sets a field in an unstructured object
41
func (uh *UnstructuredHelper) SetField(obj *unstructured.Unstructured, value interface{}, fields ...string) error {
42
    return unstructured.SetNestedField(obj.Object, value, fields...)
43
}
44

45
// Example: Creating a deployment using unstructured
46
func createDeploymentUnstructured() *unstructured.Unstructured {
47
    deployment := &unstructured.Unstructured{
48
        Object: map[string]interface{}{
49
            "apiVersion": "apps/v1",
50
            "kind":       "Deployment",
51
            "metadata": map[string]interface{}{
52
                "name":      "nginx-deployment",
53
                "namespace": "default",
54
                "labels": map[string]interface{}{
55
                    "app": "nginx",
56
                },
57
            },
58
            "spec": map[string]interface{}{
59
                "replicas": int64(3),
60
                "selector": map[string]interface{}{
61
                    "matchLabels": map[string]interface{}{
62
                        "app": "nginx",
63
                    },
64
                },
65
                "template": map[string]interface{}{
66
                    "metadata": map[string]interface{}{
67
                        "labels": map[string]interface{}{
68
                            "app": "nginx",
69
                        },
70
                    },
71
                    "spec": map[string]interface{}{
72
                        "containers": []interface{}{
73
                            map[string]interface{}{
74
                                "name":  "nginx",
75
                                "image": "nginx:1.21",
76
                                "ports": []interface{}{
77
                                    map[string]interface{}{
78
                                        "containerPort": int64(80),
79
                                    },
80
                                },
81
                            },
82
                        },
83
                    },
84
                },
85
            },
86
        },
87
    }
88
    return deployment
89
}

Building Generic Controllers#

1. Generic Resource Controller#

1
package controller
2

3
import (
4
    "context"
5
    "fmt"
6
    "time"
7

8
    "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
9
    "k8s.io/apimachinery/pkg/runtime/schema"
10
    "k8s.io/apimachinery/pkg/util/runtime"
11
    "k8s.io/apimachinery/pkg/util/wait"
12
    "k8s.io/client-go/dynamic"
13
    "k8s.io/client-go/dynamic/dynamicinformer"
14
    "k8s.io/client-go/tools/cache"
15
    "k8s.io/client-go/util/workqueue"
16
)
17

18
// GenericController watches and processes any Kubernetes resource
19
type GenericController struct {
20
    dynamicClient   dynamic.Interface
21
    informerFactory dynamicinformer.DynamicSharedInformerFactory
22
    informer        cache.SharedIndexInformer
23
    queue           workqueue.RateLimitingInterface
24
    gvr             schema.GroupVersionResource
25
    handler         ResourceHandler
26
}
27

28
// ResourceHandler defines the interface for handling resource events
29
type ResourceHandler interface {
30
    OnAdd(obj *unstructured.Unstructured) error
31
    OnUpdate(oldObj, newObj *unstructured.Unstructured) error
32
    OnDelete(obj *unstructured.Unstructured) error
33
}
34

35
// NewGenericController creates a controller for any resource type
36
func NewGenericController(
37
    dynamicClient dynamic.Interface,
38
    gvr schema.GroupVersionResource,
39
    handler ResourceHandler,
40
    resyncPeriod time.Duration,
41
) *GenericController {
42

43
    informerFactory := dynamicinformer.NewDynamicSharedInformerFactory(
44
        dynamicClient,
45
        resyncPeriod,
46
    )
47

48
    informer := informerFactory.ForResource(gvr).Informer()
49

50
    queue := workqueue.NewRateLimitingQueue(
51
        workqueue.DefaultControllerRateLimiter(),
52
    )
53

54
    controller := &GenericController{
55
        dynamicClient:   dynamicClient,
56
        informerFactory: informerFactory,
57
        informer:        informer,
58
        queue:           queue,
59
        gvr:             gvr,
60
        handler:         handler,
61
    }
62

63
    // Set up event handlers
64
    informer.AddEventHandler(cache.ResourceEventHandlerFuncs{
65
        AddFunc: func(obj interface{}) {
66
            controller.enqueue(obj)
67
        },
68
        UpdateFunc: func(oldObj, newObj interface{}) {
69
            controller.enqueue(newObj)
70
        },
71
        DeleteFunc: func(obj interface{}) {
72
            controller.enqueue(obj)
73
        },
74
    })
75

76
    return controller
77
}
78

79
// enqueue adds an object to the workqueue
80
func (gc *GenericController) enqueue(obj interface{}) {
81
    key, err := cache.MetaNamespaceKeyFunc(obj)
82
    if err != nil {
83
        runtime.HandleError(err)
84
        return
85
    }
86
    gc.queue.Add(key)
87
}
88

89
// Run starts the controller
90
func (gc *GenericController) Run(ctx context.Context, workers int) error {
91
    defer runtime.HandleCrash()
92
    defer gc.queue.ShutDown()
93

94
    // Start the informer
95
    gc.informerFactory.Start(ctx.Done())
96

97
    // Wait for cache sync
98
    if !cache.WaitForCacheSync(ctx.Done(), gc.informer.HasSynced) {
99
        return fmt.Errorf("failed to sync cache")
100
    }
101

102
    // Start workers
103
    for i := 0; i < workers; i++ {
104
        go wait.UntilWithContext(ctx, gc.runWorker, time.Second)
105
    }
106

107
    <-ctx.Done()
108
    return nil
109
}
110

111
// runWorker processes items from the queue
112
func (gc *GenericController) runWorker(ctx context.Context) {
113
    for gc.processNextItem(ctx) {
114
    }
115
}
116

117
// processNextItem handles a single item from the queue
118
func (gc *GenericController) processNextItem(ctx context.Context) bool {
119
    item, shutdown := gc.queue.Get()
120
    if shutdown {
121
        return false
122
    }
123
    defer gc.queue.Done(item)
124

125
    key, ok := item.(string)
126
    if !ok {
127
        gc.queue.Forget(item)
128
        runtime.HandleError(fmt.Errorf("expected string in queue but got %T", item))
129
        return true
130
    }
131

132
    if err := gc.syncHandler(ctx, key); err != nil {
133
        gc.queue.AddRateLimited(key)
134
        runtime.HandleError(fmt.Errorf("sync %q failed: %v", key, err))
135
        return true
136
    }
137

138
    gc.queue.Forget(item)
139
    return true
140
}
141

142
// syncHandler processes a single resource
143
func (gc *GenericController) syncHandler(ctx context.Context, key string) error {
144
    namespace, name, err := cache.SplitMetaNamespaceKey(key)
145
    if err != nil {
146
        return err
147
    }
148

149
    // Get the resource from the informer cache
150
    obj, exists, err := gc.informer.GetIndexer().GetByKey(key)
151
    if err != nil {
152
        return err
153
    }
154

155
    if !exists {
156
        // Resource was deleted
157
        return gc.handler.OnDelete(&unstructured.Unstructured{
158
            Object: map[string]interface{}{
159
                "metadata": map[string]interface{}{
160
                    "name":      name,
161
                    "namespace": namespace,
162
                },
163
            },
164
        })
165
    }
166

167
    // Convert to unstructured
168
    unstructuredObj, ok := obj.(*unstructured.Unstructured)
169
    if !ok {
170
        return fmt.Errorf("object is not unstructured: %T", obj)
171
    }
172

173
    // For simplicity, always call OnUpdate
174
    return gc.handler.OnUpdate(unstructuredObj, unstructuredObj)
175
}

2. Multi-Resource Controller#

1
// MultiResourceController manages multiple resource types
2
type MultiResourceController struct {
3
    controllers map[schema.GroupVersionResource]*GenericController
4
    client      dynamic.Interface
5
}
6

7
// NewMultiResourceController creates a controller that watches multiple resources
8
func NewMultiResourceController(client dynamic.Interface) *MultiResourceController {
9
    return &MultiResourceController{
10
        controllers: make(map[schema.GroupVersionResource]*GenericController),
11
        client:      client,
12
    }
13
}
14

15
// AddResource adds a resource type to watch
16
func (mrc *MultiResourceController) AddResource(
17
    gvr schema.GroupVersionResource,
18
    handler ResourceHandler,
19
) {
20
    controller := NewGenericController(
21
        mrc.client,
22
        gvr,
23
        handler,
24
        30*time.Second,
25
    )
26
    mrc.controllers[gvr] = controller
27
}
28

29
// Run starts all controllers
30
func (mrc *MultiResourceController) Run(ctx context.Context, workers int) error {
31
    errChan := make(chan error, len(mrc.controllers))
32

33
    for gvr, controller := range mrc.controllers {
34
        go func(g schema.GroupVersionResource, c *GenericController) {
35
            if err := c.Run(ctx, workers); err != nil {
36
                errChan <- fmt.Errorf("controller for %v failed: %w", g, err)
37
            }
38
        }(gvr, controller)
39
    }
40

41
    select {
42
    case err := <-errChan:
43
        return err
44
    case <-ctx.Done():
45
        return nil
46
    }
47
}
48

49
// Example handler implementation
50
type LoggingHandler struct {
51
    logger *log.Logger
52
}
53

54
func (lh *LoggingHandler) OnAdd(obj *unstructured.Unstructured) error {
55
    lh.logger.Printf("Resource added: %s/%s",
56
        obj.GetNamespace(), obj.GetName())
57
    return nil
58
}
59

60
func (lh *LoggingHandler) OnUpdate(oldObj, newObj *unstructured.Unstructured) error {
61
    if oldObj.GetResourceVersion() != newObj.GetResourceVersion() {
62
        lh.logger.Printf("Resource updated: %s/%s (version %s -> %s)",
63
            newObj.GetNamespace(), newObj.GetName(),
64
            oldObj.GetResourceVersion(), newObj.GetResourceVersion())
65
    }
66
    return nil
67
}
68

69
func (lh *LoggingHandler) OnDelete(obj *unstructured.Unstructured) error {
70
    lh.logger.Printf("Resource deleted: %s/%s",
71
        obj.GetNamespace(), obj.GetName())
72
    return nil
73
}

Advanced Patterns#

1. Resource Discovery and Introspection#

1
// ResourceDiscovery provides resource discovery capabilities
2
type ResourceDiscovery struct {
3
    discovery discovery.DiscoveryInterface
4
}
5

6
// NewResourceDiscovery creates a new resource discovery client
7
func NewResourceDiscovery(discovery discovery.DiscoveryInterface) *ResourceDiscovery {
8
    return &ResourceDiscovery{discovery: discovery}
9
}
10

11
// ListAllResources discovers all available resources in the cluster
12
func (rd *ResourceDiscovery) ListAllResources() ([]schema.GroupVersionResource, error) {
13
    _, apiResourceLists, err := rd.discovery.ServerGroupsAndResources()
14
    if err != nil {
15
        return nil, err
16
    }
17

18
    var resources []schema.GroupVersionResource
19

20
    for _, apiResourceList := range apiResourceLists {
21
        gv, err := schema.ParseGroupVersion(apiResourceList.GroupVersion)
22
        if err != nil {
23
            continue
24
        }
25

26
        for _, apiResource := range apiResourceList.APIResources {
27
            // Skip subresources
28
            if strings.Contains(apiResource.Name, "/") {
29
                continue
30
            }
31

32
            resources = append(resources, schema.GroupVersionResource{
33
                Group:    gv.Group,
34
                Version:  gv.Version,
35
                Resource: apiResource.Name,
36
            })
37
        }
38
    }
39

40
    return resources, nil
41
}
42

43
// GetResourceDetails returns detailed information about a resource
44
func (rd *ResourceDiscovery) GetResourceDetails(gvr schema.GroupVersionResource) (*metav1.APIResource, error) {
45
    resources, err := rd.discovery.ServerResourcesForGroupVersion(
46
        gvr.GroupVersion().String(),
47
    )
48
    if err != nil {
49
        return nil, err
50
    }
51

52
    for _, resource := range resources.APIResources {
53
        if resource.Name == gvr.Resource {
54
            return &resource, nil
55
        }
56
    }
57

58
    return nil, fmt.Errorf("resource %v not found", gvr)
59
}
60

61
// IsNamespaced checks if a resource is namespaced
62
func (rd *ResourceDiscovery) IsNamespaced(gvr schema.GroupVersionResource) (bool, error) {
63
    resource, err := rd.GetResourceDetails(gvr)
64
    if err != nil {
65
        return false, err
66
    }
67
    return resource.Namespaced, nil
68
}
69

70
// SupportsVerb checks if a resource supports a specific verb
71
func (rd *ResourceDiscovery) SupportsVerb(gvr schema.GroupVersionResource, verb string) (bool, error) {
72
    resource, err := rd.GetResourceDetails(gvr)
73
    if err != nil {
74
        return false, err
75
    }
76

77
    for _, v := range resource.Verbs {
78
        if v == verb {
79
            return true, nil
80
        }
81
    }
82
    return false, nil
83
}

2. Field Selectors and Advanced Queries#

1
// QueryBuilder builds complex queries for dynamic resources
2
type QueryBuilder struct {
3
    labelSelector string
4
    fieldSelector string
5
    limit         int64
6
    continueToken string
7
}
8

9
// NewQueryBuilder creates a new query builder
10
func NewQueryBuilder() *QueryBuilder {
11
    return &QueryBuilder{}
12
}
13

14
// WithLabelSelector adds a label selector
15
func (qb *QueryBuilder) WithLabelSelector(selector string) *QueryBuilder {
16
    qb.labelSelector = selector
17
    return qb
18
}
19

20
// WithFieldSelector adds a field selector
21
func (qb *QueryBuilder) WithFieldSelector(selector string) *QueryBuilder {
22
    qb.fieldSelector = selector
23
    return qb
24
}
25

26
// WithLimit sets the result limit
27
func (qb *QueryBuilder) WithLimit(limit int64) *QueryBuilder {
28
    qb.limit = limit
29
    return qb
30
}
31

32
// WithContinue sets the continue token for pagination
33
func (qb *QueryBuilder) WithContinue(token string) *QueryBuilder {
34
    qb.continueToken = token
35
    return qb
36
}
37

38
// Build creates ListOptions from the query
39
func (qb *QueryBuilder) Build() metav1.ListOptions {
40
    return metav1.ListOptions{
41
        LabelSelector: qb.labelSelector,
42
        FieldSelector: qb.fieldSelector,
43
        Limit:         qb.limit,
44
        Continue:      qb.continueToken,
45
    }
46
}
47

48
// ResourceQuery performs advanced queries on resources
49
type ResourceQuery struct {
50
    client dynamic.Interface
51
}
52

53
// FindResourcesByLabel finds all resources matching a label across namespaces
54
func (rq *ResourceQuery) FindResourcesByLabel(
55
    ctx context.Context,
56
    gvr schema.GroupVersionResource,
57
    labelKey, labelValue string,
58
) ([]*unstructured.Unstructured, error) {
59

60
    query := NewQueryBuilder().
61
        WithLabelSelector(fmt.Sprintf("%s=%s", labelKey, labelValue)).
62
        Build()
63

64
    list, err := rq.client.Resource(gvr).
65
        List(ctx, query)
66
    if err != nil {
67
        return nil, err
68
    }
69

70
    var results []*unstructured.Unstructured
71
    for i := range list.Items {
72
        results = append(results, &list.Items[i])
73
    }
74

75
    return results, nil
76
}
77

78
// FindResourcesByFieldPath finds resources by a field path value
79
func (rq *ResourceQuery) FindResourcesByFieldPath(
80
    ctx context.Context,
81
    gvr schema.GroupVersionResource,
82
    namespace string,
83
    fieldPath string,
84
    fieldValue interface{},
85
) ([]*unstructured.Unstructured, error) {
86

87
    list, err := rq.client.Resource(gvr).
88
        Namespace(namespace).
89
        List(ctx, metav1.ListOptions{})
90
    if err != nil {
91
        return nil, err
92
    }
93

94
    var results []*unstructured.Unstructured
95
    fields := strings.Split(fieldPath, ".")
96

97
    for i := range list.Items {
98
        val, found, err := unstructured.NestedFieldNoCopy(
99
            list.Items[i].Object,
100
            fields...,
101
        )
102
        if err != nil || !found {
103
            continue
104
        }
105

106
        if val == fieldValue {
107
            results = append(results, &list.Items[i])
108
        }
109
    }
110

111
    return results, nil
112
}

Working with Custom Resources#

1. CRD Client without Dependencies#

1
// CRDClient provides operations for custom resources without importing their packages
2
type CRDClient struct {
3
    dynamic   dynamic.Interface
4
    discovery discovery.DiscoveryInterface
5
    mapper    meta.RESTMapper
6
}
7

8
// NewCRDClient creates a client for working with CRDs
9
func NewCRDClient(config *rest.Config) (*CRDClient, error) {
10
    dynamic, err := dynamic.NewForConfig(config)
11
    if err != nil {
12
        return nil, err
13
    }
14

15
    discovery, err := discovery.NewDiscoveryClientForConfig(config)
16
    if err != nil {
17
        return nil, err
18
    }
19

20
    mapper := restmapper.NewDeferredDiscoveryRESTMapper(
21
        memory.NewMemCacheClient(discovery),
22
    )
23

24
    return &CRDClient{
25
        dynamic:   dynamic,
26
        discovery: discovery,
27
        mapper:    mapper,
28
    }, nil
29
}
30

31
// GetCRD retrieves a custom resource
32
func (cc *CRDClient) GetCRD(
33
    ctx context.Context,
34
    apiVersion, kind, namespace, name string,
35
) (*unstructured.Unstructured, error) {
36

37
    gv, err := schema.ParseGroupVersion(apiVersion)
38
    if err != nil {
39
        return nil, err
40
    }
41

42
    gvk := gv.WithKind(kind)
43
    mapping, err := cc.mapper.RESTMapping(gvk.GroupKind(), gv.Version)
44
    if err != nil {
45
        return nil, err
46
    }
47

48
    var dr dynamic.ResourceInterface
49
    if mapping.Scope.Name() == meta.RESTScopeNameNamespace {
50
        dr = cc.dynamic.Resource(mapping.Resource).Namespace(namespace)
51
    } else {
52
        dr = cc.dynamic.Resource(mapping.Resource)
53
    }
54

55
    return dr.Get(ctx, name, metav1.GetOptions{})
56
}
57

58
// Example: Working with Prometheus ServiceMonitor CRD
59
func (cc *CRDClient) CreateServiceMonitor(ctx context.Context) error {
60
    serviceMonitor := &unstructured.Unstructured{
61
        Object: map[string]interface{}{
62
            "apiVersion": "monitoring.coreos.com/v1",
63
            "kind":       "ServiceMonitor",
64
            "metadata": map[string]interface{}{
65
                "name":      "app-metrics",
66
                "namespace": "monitoring",
67
                "labels": map[string]interface{}{
68
                    "app": "my-app",
69
                },
70
            },
71
            "spec": map[string]interface{}{
72
                "selector": map[string]interface{}{
73
                    "matchLabels": map[string]interface{}{
74
                        "app": "my-app",
75
                    },
76
                },
77
                "endpoints": []interface{}{
78
                    map[string]interface{}{
79
                        "port":     "metrics",
80
                        "interval": "30s",
81
                        "path":     "/metrics",
82
                    },
83
                },
84
            },
85
        },
86
    }
87

88
    gvr := schema.GroupVersionResource{
89
        Group:    "monitoring.coreos.com",
90
        Version:  "v1",
91
        Resource: "servicemonitors",
92
    }
93

94
    _, err := cc.dynamic.Resource(gvr).
95
        Namespace("monitoring").
96
        Create(ctx, serviceMonitor, metav1.CreateOptions{})
97

98
    return err
99
}

2. Generic CRD Watcher#

1
// CRDWatcher watches for changes to any CRD type
2
type CRDWatcher struct {
3
    client    dynamic.Interface
4
    gvr       schema.GroupVersionResource
5
    namespace string
6
    handler   func(*unstructured.Unstructured, watch.EventType)
7
}
8

9
// NewCRDWatcher creates a watcher for a CRD type
10
func NewCRDWatcher(
11
    client dynamic.Interface,
12
    gvr schema.GroupVersionResource,
13
    namespace string,
14
    handler func(*unstructured.Unstructured, watch.EventType),
15
) *CRDWatcher {
16
    return &CRDWatcher{
17
        client:    client,
18
        gvr:       gvr,
19
        namespace: namespace,
20
        handler:   handler,
21
    }
22
}
23

24
// Watch starts watching for CRD changes
25
func (cw *CRDWatcher) Watch(ctx context.Context) error {
26
    var resourceInterface dynamic.ResourceInterface
27

28
    if cw.namespace != "" {
29
        resourceInterface = cw.client.Resource(cw.gvr).Namespace(cw.namespace)
30
    } else {
31
        resourceInterface = cw.client.Resource(cw.gvr)
32
    }
33

34
    watcher, err := resourceInterface.Watch(ctx, metav1.ListOptions{})
35
    if err != nil {
36
        return err
37
    }
38
    defer watcher.Stop()
39

40
    for {
41
        select {
42
        case event, ok := <-watcher.ResultChan():
43
            if !ok {
44
                return fmt.Errorf("watch channel closed")
45
            }
46

47
            unstructuredObj, ok := event.Object.(*unstructured.Unstructured)
48
            if !ok {
49
                continue
50
            }
51

52
            cw.handler(unstructuredObj, event.Type)
53

54
        case <-ctx.Done():
55
            return ctx.Err()
56
        }
57
    }
58
}

Performance Optimization#

1. Batch Operations#

1
// BatchProcessor processes resources in batches for better performance
2
type BatchProcessor struct {
3
    client    dynamic.Interface
4
    batchSize int
5
    workers   int
6
}
7

8
// NewBatchProcessor creates a batch processor
9
func NewBatchProcessor(client dynamic.Interface, batchSize, workers int) *BatchProcessor {
10
    return &BatchProcessor{
11
        client:    client,
12
        batchSize: batchSize,
13
        workers:   workers,
14
    }
15
}
16

17
// ProcessResources processes resources in parallel batches
18
func (bp *BatchProcessor) ProcessResources(
19
    ctx context.Context,
20
    gvr schema.GroupVersionResource,
21
    processor func(*unstructured.Unstructured) error,
22
) error {
23

24
    // Create work channel
25
    workChan := make(chan *unstructured.Unstructured, bp.batchSize)
26
    errChan := make(chan error, bp.workers)
27

28
    // Start workers
29
    var wg sync.WaitGroup
30
    for i := 0; i < bp.workers; i++ {
31
        wg.Add(1)
32
        go func() {
33
            defer wg.Done()
34
            for obj := range workChan {
35
                if err := processor(obj); err != nil {
36
                    errChan <- err
37
                    return
38
                }
39
            }
40
        }()
41
    }
42

43
    // List and process resources
44
    continueToken := ""
45
    for {
46
        list, err := bp.client.Resource(gvr).List(ctx, metav1.ListOptions{
47
            Limit:    int64(bp.batchSize),
48
            Continue: continueToken,
49
        })
50
        if err != nil {
51
            close(workChan)
52
            return err
53
        }
54

55
        for i := range list.Items {
56
            select {
57
            case workChan <- &list.Items[i]:
58
            case err := <-errChan:
59
                close(workChan)
60
                return err
61
            case <-ctx.Done():
62
                close(workChan)
63
                return ctx.Err()
64
            }
65
        }
66

67
        continueToken = list.GetContinue()
68
        if continueToken == "" {
69
            break
70
        }
71
    }
72

73
    close(workChan)
74
    wg.Wait()
75

76
    select {
77
    case err := <-errChan:
78
        return err
79
    default:
80
        return nil
81
    }
82
}

2. Caching Layer#

1
// CachedDynamicClient adds caching to dynamic client operations
2
type CachedDynamicClient struct {
3
    client dynamic.Interface
4
    cache  *cache.LRU
5
    ttl    time.Duration
6
}
7

8
// CacheEntry represents a cached resource
9
type CacheEntry struct {
10
    Object    *unstructured.Unstructured
11
    ExpiresAt time.Time
12
}
13

14
// NewCachedDynamicClient creates a cached dynamic client
15
func NewCachedDynamicClient(client dynamic.Interface, cacheSize int, ttl time.Duration) *CachedDynamicClient {
16
    return &CachedDynamicClient{
17
        client: client,
18
        cache:  cache.NewLRU(cacheSize),
19
        ttl:    ttl,
20
    }
21
}
22

23
// Get retrieves a resource with caching
24
func (cdc *CachedDynamicClient) Get(
25
    ctx context.Context,
26
    gvr schema.GroupVersionResource,
27
    namespace, name string,
28
) (*unstructured.Unstructured, error) {
29

30
    // Build cache key
31
    key := fmt.Sprintf("%s/%s/%s/%s", gvr.String(), namespace, name, "get")
32

33
    // Check cache
34
    if cached, ok := cdc.cache.Get(key); ok {
35
        entry := cached.(*CacheEntry)
36
        if time.Now().Before(entry.ExpiresAt) {
37
            return entry.Object.DeepCopy(), nil
38
        }
39
        cdc.cache.Remove(key)
40
    }
41

42
    // Fetch from API
43
    var dr dynamic.ResourceInterface
44
    if namespace != "" {
45
        dr = cdc.client.Resource(gvr).Namespace(namespace)
46
    } else {
47
        dr = cdc.client.Resource(gvr)
48
    }
49

50
    obj, err := dr.Get(ctx, name, metav1.GetOptions{})
51
    if err != nil {
52
        return nil, err
53
    }
54

55
    // Store in cache
56
    cdc.cache.Add(key, &CacheEntry{
57
        Object:    obj,
58
        ExpiresAt: time.Now().Add(cdc.ttl),
59
    })
60

61
    return obj, nil
62
}
63

64
// InvalidateCache removes entries from cache
65
func (cdc *CachedDynamicClient) InvalidateCache(gvr schema.GroupVersionResource, namespace, name string) {
66
    pattern := fmt.Sprintf("%s/%s/%s/", gvr.String(), namespace, name)
67

68
    for _, key := range cdc.cache.Keys() {
69
        if strings.HasPrefix(key.(string), pattern) {
70
            cdc.cache.Remove(key)
71
        }
72
    }
73
}

Real-World Examples#

1. Resource Migration Tool#

1
// ResourceMigrator migrates resources between clusters or namespaces
2
type ResourceMigrator struct {
3
    sourceClient dynamic.Interface
4
    targetClient dynamic.Interface
5
    discovery    discovery.DiscoveryInterface
6
}
7

8
// MigrateResources migrates resources based on criteria
9
func (rm *ResourceMigrator) MigrateResources(
10
    ctx context.Context,
11
    gvr schema.GroupVersionResource,
12
    sourceNamespace, targetNamespace string,
13
    transformer func(*unstructured.Unstructured) error,
14
) error {
15

16
    // List resources from source
17
    list, err := rm.sourceClient.Resource(gvr).
18
        Namespace(sourceNamespace).
19
        List(ctx, metav1.ListOptions{})
20
    if err != nil {
21
        return fmt.Errorf("failed to list resources: %w", err)
22
    }
23

24
    log.Printf("Found %d resources to migrate", len(list.Items))
25

26
    for i := range list.Items {
27
        obj := list.Items[i].DeepCopy()
28

29
        // Clean metadata
30
        unstructured.RemoveNestedField(obj.Object, "metadata", "uid")
31
        unstructured.RemoveNestedField(obj.Object, "metadata", "resourceVersion")
32
        unstructured.RemoveNestedField(obj.Object, "metadata", "selfLink")
33
        unstructured.RemoveNestedField(obj.Object, "metadata", "creationTimestamp")
34
        unstructured.RemoveNestedField(obj.Object, "metadata", "generation")
35

36
        // Update namespace
37
        obj.SetNamespace(targetNamespace)
38

39
        // Apply transformation
40
        if transformer != nil {
41
            if err := transformer(obj); err != nil {
42
                log.Printf("Failed to transform %s: %v", obj.GetName(), err)
43
                continue
44
            }
45
        }
46

47
        // Create in target
48
        _, err := rm.targetClient.Resource(gvr).
49
            Namespace(targetNamespace).
50
            Create(ctx, obj, metav1.CreateOptions{})
51

52
        if err != nil {
53
            if errors.IsAlreadyExists(err) {
54
                log.Printf("Resource %s already exists in target", obj.GetName())
55
            } else {
56
                log.Printf("Failed to create %s: %v", obj.GetName(), err)
57
            }
58
        } else {
59
            log.Printf("Successfully migrated %s", obj.GetName())
60
        }
61
    }
62

63
    return nil
64
}

2. Resource Relationship Mapper#

1
// ResourceRelationshipMapper maps relationships between resources
2
type ResourceRelationshipMapper struct {
3
    client    dynamic.Interface
4
    discovery discovery.DiscoveryInterface
5
}
6

7
// Relationship represents a relationship between resources
8
type Relationship struct {
9
    Source ResourceRef
10
    Target ResourceRef
11
    Type   string // "owns", "references", "uses"
12
}
13

14
// ResourceRef identifies a resource
15
type ResourceRef struct {
16
    GVR       schema.GroupVersionResource
17
    Namespace string
18
    Name      string
19
}
20

21
// MapRelationships discovers relationships for a resource
22
func (rrm *ResourceRelationshipMapper) MapRelationships(
23
    ctx context.Context,
24
    ref ResourceRef,
25
) ([]Relationship, error) {
26

27
    var relationships []Relationship
28

29
    // Get the source resource
30
    var dr dynamic.ResourceInterface
31
    if ref.Namespace != "" {
32
        dr = rrm.client.Resource(ref.GVR).Namespace(ref.Namespace)
33
    } else {
34
        dr = rrm.client.Resource(ref.GVR)
35
    }
36

37
    obj, err := dr.Get(ctx, ref.Name, metav1.GetOptions{})
38
    if err != nil {
39
        return nil, err
40
    }
41

42
    // Check owner references
43
    for _, owner := range obj.GetOwnerReferences() {
44
        gv, _ := schema.ParseGroupVersion(owner.APIVersion)
45
        relationships = append(relationships, Relationship{
46
            Source: ref,
47
            Target: ResourceRef{
48
                GVR: schema.GroupVersionResource{
49
                    Group:    gv.Group,
50
                    Version:  gv.Version,
51
                    Resource: strings.ToLower(owner.Kind) + "s", // Simple pluralization
52
                },
53
                Namespace: ref.Namespace,
54
                Name:      owner.Name,
55
            },
56
            Type: "owns",
57
        })
58
    }
59

60
    // Check for ConfigMap/Secret references in Pod specs
61
    if ref.GVR.Resource == "pods" {
62
        relationships = append(relationships,
63
            rrm.extractPodReferences(obj)...)
64
    }
65

66
    // Check for Service selectors
67
    if ref.GVR.Resource == "services" {
68
        relationships = append(relationships,
69
            rrm.findMatchingPods(ctx, obj)...)
70
    }
71

72
    return relationships, nil
73
}
74

75
// extractPodReferences finds ConfigMap and Secret references in a Pod
76
func (rrm *ResourceRelationshipMapper) extractPodReferences(
77
    pod *unstructured.Unstructured,
78
) []Relationship {
79

80
    var relationships []Relationship
81
    namespace := pod.GetNamespace()
82

83
    // Extract containers
84
    containers, found, _ := unstructured.NestedSlice(
85
        pod.Object, "spec", "containers")
86
    if !found {
87
        return relationships
88
    }
89

90
    for _, container := range containers {
91
        containerMap, ok := container.(map[string]interface{})
92
        if !ok {
93
            continue
94
        }
95

96
        // Check envFrom
97
        envFromList, found, _ := unstructured.NestedSlice(
98
            containerMap, "envFrom")
99
        if found {
100
            for _, envFrom := range envFromList {
101
                envFromMap, ok := envFrom.(map[string]interface{})
102
                if !ok {
103
                    continue
104
                }
105

106
                // ConfigMapRef
107
                if cmRef, found, _ := unstructured.NestedMap(
108
                    envFromMap, "configMapRef"); found {
109
                    if name, ok := cmRef["name"].(string); ok {
110
                        relationships = append(relationships, Relationship{
111
                            Source: ResourceRef{
112
                                GVR:       schema.GroupVersionResource{Version: "v1", Resource: "pods"},
113
                                Namespace: namespace,
114
                                Name:      pod.GetName(),
115
                            },
116
                            Target: ResourceRef{
117
                                GVR:       schema.GroupVersionResource{Version: "v1", Resource: "configmaps"},
118
                                Namespace: namespace,
119
                                Name:      name,
120
                            },
121
                            Type: "references",
122
                        })
123
                    }
124
                }
125

126
                // SecretRef
127
                if secretRef, found, _ := unstructured.NestedMap(
128
                    envFromMap, "secretRef"); found {
129
                    if name, ok := secretRef["name"].(string); ok {
130
                        relationships = append(relationships, Relationship{
131
                            Source: ResourceRef{
132
                                GVR:       schema.GroupVersionResource{Version: "v1", Resource: "pods"},
133
                                Namespace: namespace,
134
                                Name:      pod.GetName(),
135
                            },
136
                            Target: ResourceRef{
137
                                GVR:       schema.GroupVersionResource{Version: "v1", Resource: "secrets"},
138
                                Namespace: namespace,
139
                                Name:      name,
140
                            },
141
                            Type: "references",
142
                        })
143
                    }
144
                }
145
            }
146
        }
147
    }
148

149
    return relationships
150
}

3. Resource Compliance Checker#

1
// ComplianceChecker checks resources against policies
2
type ComplianceChecker struct {
3
    client dynamic.Interface
4
    rules  []ComplianceRule
5
}
6

7
// ComplianceRule defines a compliance check
8
type ComplianceRule struct {
9
    Name        string
10
    Description string
11
    GVR         schema.GroupVersionResource
12
    Check       func(*unstructured.Unstructured) (bool, string)
13
}
14

15
// CheckCompliance runs compliance checks on resources
16
func (cc *ComplianceChecker) CheckCompliance(ctx context.Context) ([]ComplianceResult, error) {
17
    var results []ComplianceResult
18

19
    for _, rule := range cc.rules {
20
        list, err := cc.client.Resource(rule.GVR).
21
            List(ctx, metav1.ListOptions{})
22
        if err != nil {
23
            log.Printf("Failed to list %v: %v", rule.GVR, err)
24
            continue
25
        }
26

27
        for i := range list.Items {
28
            compliant, reason := rule.Check(&list.Items[i])
29

30
            results = append(results, ComplianceResult{
31
                Rule:      rule.Name,
32
                Resource:  fmt.Sprintf("%s/%s", list.Items[i].GetNamespace(), list.Items[i].GetName()),
33
                Compliant: compliant,
34
                Reason:    reason,
35
            })
36
        }
37
    }
38

39
    return results, nil
40
}
41

42
// ComplianceResult represents the result of a compliance check
43
type ComplianceResult struct {
44
    Rule      string
45
    Resource  string
46
    Compliant bool
47
    Reason    string
48
}
49

50
// Example compliance rules
51
func GetDefaultComplianceRules() []ComplianceRule {
52
    return []ComplianceRule{
53
        {
54
            Name:        "pod-security-context",
55
            Description: "Pods must have security context",
56
            GVR:         schema.GroupVersionResource{Version: "v1", Resource: "pods"},
57
            Check: func(obj *unstructured.Unstructured) (bool, string) {
58
                secContext, found, _ := unstructured.NestedMap(
59
                    obj.Object, "spec", "securityContext")
60
                if !found || secContext == nil {
61
                    return false, "Missing security context"
62
                }
63

64
                runAsNonRoot, found, _ := unstructured.NestedBool(
65
                    secContext, "runAsNonRoot")
66
                if !found || !runAsNonRoot {
67
                    return false, "Must run as non-root"
68
                }
69

70
                return true, "Compliant"
71
            },
72
        },
73
        {
74
            Name:        "resource-limits",
75
            Description: "Containers must have resource limits",
76
            GVR:         schema.GroupVersionResource{Version: "v1", Resource: "pods"},
77
            Check: func(obj *unstructured.Unstructured) (bool, string) {
78
                containers, found, _ := unstructured.NestedSlice(
79
                    obj.Object, "spec", "containers")
80
                if !found {
81
                    return false, "No containers found"
82
                }
83

84
                for _, container := range containers {
85
                    containerMap, ok := container.(map[string]interface{})
86
                    if !ok {
87
                        continue
88
                    }
89

90
                    limits, found, _ := unstructured.NestedMap(
91
                        containerMap, "resources", "limits")
92
                    if !found || limits == nil {
93
                        return false, "Missing resource limits"
94
                    }
95

96
                    if _, ok := limits["memory"]; !ok {
97
                        return false, "Missing memory limit"
98
                    }
99
                    if _, ok := limits["cpu"]; !ok {
100
                        return false, "Missing CPU limit"
101
                    }
102
                }
103

104
                return true, "All containers have limits"
105
            },
106
        },
107
        {
108
            Name:        "required-labels",
109
            Description: "Resources must have required labels",
110
            GVR:         schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "deployments"},
111
            Check: func(obj *unstructured.Unstructured) (bool, string) {
112
                labels := obj.GetLabels()
113
                requiredLabels := []string{"team", "environment", "app"}
114

115
                for _, required := range requiredLabels {
116
                    if _, ok := labels[required]; !ok {
117
                        return false, fmt.Sprintf("Missing label: %s", required)
118
                    }
119
                }
120

121
                return true, "Has all required labels"
122
            },
123
        },
124
    }
125
}

Testing Dynamic Client Code#

Unit Testing with Fake Client#

1
// Example unit test for dynamic client operations
2
func TestDynamicClientOperations(t *testing.T) {
3
    // Create fake dynamic client
4
    scheme := runtime.NewScheme()
5
    _ = corev1.AddToScheme(scheme)
6

7
    pod := &unstructured.Unstructured{
8
        Object: map[string]interface{}{
9
            "apiVersion": "v1",
10
            "kind":       "Pod",
11
            "metadata": map[string]interface{}{
12
                "name":      "test-pod",
13
                "namespace": "default",
14
            },
15
            "spec": map[string]interface{}{
16
                "containers": []interface{}{
17
                    map[string]interface{}{
18
                        "name":  "nginx",
19
                        "image": "nginx:latest",
20
                    },
21
                },
22
            },
23
        },
24
    }
25

26
    client := fake.NewSimpleDynamicClient(scheme, pod)
27

28
    // Test Get operation
29
    gvr := schema.GroupVersionResource{
30
        Version:  "v1",
31
        Resource: "pods",
32
    }
33

34
    result, err := client.Resource(gvr).
35
        Namespace("default").
36
        Get(context.TODO(), "test-pod", metav1.GetOptions{})
37

38
    assert.NoError(t, err)
39
    assert.Equal(t, "test-pod", result.GetName())
40

41
    // Test Update operation
42
    result.SetLabels(map[string]string{"test": "label"})
43
    updated, err := client.Resource(gvr).
44
        Namespace("default").
45
        Update(context.TODO(), result, metav1.UpdateOptions{})
46

47
    assert.NoError(t, err)
48
    assert.Equal(t, "label", updated.GetLabels()["test"])
49
}

Conclusion#

The Kubernetes dynamic client provides unparalleled flexibility for building generic tools and operators. By mastering these patterns, you can create powerful controllers that work with any resource type, adapt to schema changes, and operate across different Kubernetes distributions.

Key Takeaways#

Use dynamic client for runtime resource discovery
Leverage unstructured objects for flexible data handling
Implement proper error handling and retries
Cache aggressively to improve performance
Use discovery for resource introspection
Build generic tools that work with any CRD

Next Steps#

Explore dynamic informers for efficient watching
Implement admission webhooks with dynamic validation
Build multi-cluster controllers with dynamic client
Create resource migration and backup tools
Develop compliance and policy engines