Watcher in Golang to get nodes in cluster

by | Nov 27, 2024 | Technology

In Go, you can create a “watcher” to monitor nodes in a cluster using the Kubernetes API. A typical implementation involves using the Kubernetes client-go library, which provides the necessary tools for interacting with Kubernetes clusters.

Here’s how you can set up a watcher to monitor nodes in a Kubernetes cluster:

Steps to Create a Node Watcher in Go

  1. Install client-go library
    Add the Kubernetes client-go library to your project. You can do this using go mod:

    bash
    go get k8s.io/client-go@latest
    go get k8s.io/apimachinery@latest
  2. Set Up Kubernetes Client
    Create a Kubernetes client that can communicate with the cluster. Use the in-cluster configuration for applications running inside the cluster or the kubeconfig file for local testing.
  3. Use Informers for Watching Resources
    Kubernetes provides informers as a highly efficient way to watch and list resources. Informers use caches to minimize API calls and provide event-driven updates.
  4. Implement Event Handlers
    Add event handlers to react to additions, updates, or deletions of nodes.

Example: Node Watcher in Go

Here’s an example implementation:

go

package main

import (
“context”
“flag”
“fmt”
“os”
“os/signal”
“syscall”

v1 “k8s.io/api/core/v1”
metav1 “k8s.io/apimachinery/pkg/apis/meta/v1”
“k8s.io/apimachinery/pkg/fields”
“k8s.io/client-go/informers”
“k8s.io/client-go/kubernetes”
“k8s.io/client-go/tools/cache”
“k8s.io/client-go/tools/clientcmd”
)

func main() {
// Load kubeconfig (for out-of-cluster use)
kubeconfig := flag.String(“kubeconfig”, “~/.kube/config”, “Path to a kubeconfig file”)
flag.Parse()

// Build the clientset
config, err := clientcmd.BuildConfigFromFlags(“”, *kubeconfig)
if err != nil {
panic(err.Error())
}

clientset, err := kubernetes.NewForConfig(config)
if err != nil {
panic(err.Error())
}

// Create a shared informer factory
factory := informers.NewSharedInformerFactory(clientset, 0)

// Create a Node informer
nodeInformer := factory.Core().V1().Nodes().Informer()

// Add event handlers
nodeInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
AddFunc: func(obj interface{}) {
node := obj.(*v1.Node)
fmt.Printf(“Node added: %s\n”, node.Name)
},
UpdateFunc: func(oldObj, newObj interface{}) {
oldNode := oldObj.(*v1.Node)
newNode := newObj.(*v1.Node)
fmt.Printf(“Node updated: %s -> %s\n”, oldNode.Name, newNode.Name)
},
DeleteFunc: func(obj interface{}) {
node := obj.(*v1.Node)
fmt.Printf(“Node deleted: %s\n”, node.Name)
},
})

// Run the informer
stopCh := make(chan struct{})
go nodeInformer.Run(stopCh)

// Wait for termination signal
signalCh := make(chan os.Signal, 1)
signal.Notify(signalCh, syscall.SIGINT, syscall.SIGTERM)
<-signalCh

close(stopCh)
}

Explanation of the Code

  1. Client Configuration:
    • Uses kubeconfig for local development. For in-cluster, use rest.InClusterConfig().
  2. Informer:
    • An informer for Node objects is created via informers.NewSharedInformerFactory.
  3. Event Handlers:
    • Handlers for AddFunc, UpdateFunc, and DeleteFunc are added to respond to changes in the cluster nodes.
  4. Run the Watcher:
    • nodeInformer.Run(stopCh) starts the watcher and listens for changes.
  5. Graceful Shutdown:
    • A signal handler ensures the application shuts down gracefully on termination signals.

Output Example

When a node is added, updated, or deleted, you’ll see log entries like:

plaintext
Node added: node1
Node updated: node1 -> node1
Node deleted: node1

Additional Notes

  • RBAC Permissions: Ensure the Kubernetes service account or user has the appropriate permissions to list and watch nodes.
  • Error Handling: Enhance the code with error checks and retry mechanisms for production use.
  • Advanced Filtering: Use field selectors (e.g., fields.OneTermEqualSelector) for more granular control over watched resources.
×
Sign in
Sign up

Sign In

Sign Up