In this guide, you’ll learn:
✔ What a dynamic informer is and how it differs from a static informer.
✔ How to set up a dynamic informer to watch Kubernetes events.
✔ Best practices for managing multiple resources efficiently.
✔ Real-world Golang code examples for dynamic informers.
✔ Common pitfalls and how to avoid them.
By the end, you’ll be able to implement a production-ready dynamic informer that scales with your Kubernetes workloads.
A dynamic informer is a Kubernetes client-go component that watches unstructured resources (like CRDs) without requiring compile-time schema definitions. Unlike static informers (which require predefined types), dynamic informers use unstructured.Unstructured to handle arbitrary Kubernetes objects.
✅ Watching Custom Resource Definitions (CRDs) dynamically.
✅ Monitoring multiple resource types with a single informer.
✅ Building generic controllers that adapt to new CRDs at runtime.
| Feature | Static Informer | Dynamic Informer |
|---|---|---|
| Resource Type | Predefined (e.g., v1.Pod) | Any (unstructured.Unstructured) |
| Flexibility | Limited to known types | Works with CRDs and unknown resources |
| Performance | Optimized for known schemas | Slightly slower due to runtime type checks |
| Use Case | Built-in resources (Pods, Deployments) | Custom resources, multi-resource watchers |
To create a dynamic informer, we’ll use:
dynamic.Interface (from k8s.io/client-go/dynamic)informer.GenericInformer (for unstructured data)cache.SharedIndexInformer (to cache and index resources)package main
import (
"k8s.io/client-go/dynamic"
"k8s.io/client-go/tools/clientcmd"
)
func main() {
// Load kubeconfig
config, err := clientcmd.BuildConfigFromFlags("", "/path/to/kubeconfig")
if err != nil {
panic(err)
}
// Create dynamic client
dynamicClient, err := dynamic.NewForConfig(config)
if err != nil {
panic(err)
}
}
Use schema.GroupVersionResource to specify which resource to watch.
import (
"k8s.io/apimachinery/pkg/runtime/schema"
)
// Example: Watch for changes in a CRD (e.g., "myresources.example.com")
gvr := schema.GroupVersionResource{
Group: "example.com",
Version: "v1",
Resource: "myresources",
}
import (
"k8s.io/client-go/informers"
)
// Create a factory for dynamic informers
factory := informers.NewSharedInformerFactoryWithOptions(
dynamicClient,
0, // Resync period (0 = no resync)
informers.WithNamespace("default"), // Optional: Watch a specific namespace
)
// Get a dynamic informer for the GVR
informer := factory.ForResource(gvr)
informer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
AddFunc: func(obj interface{}) {
// Handle newly created resource
log.Println("Resource added:", obj)
},
UpdateFunc: func(oldObj, newObj interface{}) {
// Handle updates
log.Println("Resource updated:", newObj)
},
DeleteFunc: func(obj interface{}) {
// Handle deletions
log.Println("Resource deleted:", obj)
},
})
stopCh := make(chan struct{})
defer close(stopCh)
factory.Start(stopCh)
factory.WaitForCacheSync(stopCh)
// Keep the informer running
select {}
Use dynamicinformer.NewDynamicSharedInformerFactory to watch multiple CRDs:
import (
"k8s.io/client-go/dynamic/dynamicinformer"
)
factory := dynamicinformer.NewDynamicSharedInformerFactory(dynamicClient, 0)
// Watch multiple GVRs
informer1 := factory.ForResource(gvr1).Informer()
informer2 := factory.ForResource(gvr2).Informer()
// Add event handlers to each
informer1.AddEventHandler(...)
informer2.AddEventHandler(...)
Use fake.NewSimpleDynamicClient for unit tests:
import (
"k8s.io/client-go/dynamic/fake"
)
// Create a fake dynamic client
fakeClient := fake.NewSimpleDynamicClient(runtime.NewScheme())
// Use in tests
factory := dynamicinformer.NewDynamicSharedInformerFactory(fakeClient, 0)
To prevent hanging, use a context with timeout:
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
// Start informer with context
go informer.Run(ctx.Done())
🔹 Optimize Performance: Use WithNamespace() to limit scope.
🔹 Error Handling: Always check cache.WaitForCacheSync().
🔹 Logging: Use structured logging (zap, logrus) for debugging.
🔹 Rate Limiting: Avoid API throttling with RateLimitingQueue.
| Issue | Solution |
|---|---|
| Informer not detecting changes | Ensure AddEventHandler is registered before starting. |
| Memory leaks | Always close(stopCh) to clean up informers. |
| API throttling | Use client-go's built-in rate limiter. |
| Unstructured parsing errors | Validate with unstructured.Unstructured.GetXXX(). |
Dynamic informers are essential for Kubernetes operators that need to watch CRDs or multiple resource types. By following this guide, you can:
✔ Set up a dynamic informer in Golang.
✔ Watch multiple resources efficiently.
✔ Handle edge cases like timeouts and testing.
Now you’re ready to build scalable, event-driven Kubernetes controllers with dynamic informers! 🚀