discovery

README

K8s-Discovery

K8s Discovery, is an effort to reduce the boiler plate code for the client-go or kubernetes based cloud native GoLang developers.

The main aspect of this is around saving and cleaning the code for in-cluster and out-cluster configurations.

Usage

Run go get to get the k8s-discovery module as follows.

go get github.com/sysbind/k8s-discovery

Declare a variable as var k8s *discovery.K8s and initialize it as k8s, _ = discovery.NewK8s(). Now the k8s will hold the interface that will provide the clientset for Kubernetes communication that is pulled either via in-cluster or via kubeconfig file.

Available APIs at the moment

NewK8s: Will return a new kubernetes clientset's interface that is formulated either via in-cluster configuration or kubeconfog file.

GetVersion: Queries the Kubernetes for the version in v0.0.0-master+$Format:%h$

GetNamespace: Gets the namespace of the running pod if running inside the cluster, if outside returns based on the POD_NAMESPACE environment variable. This environment variable also takes precedence if provided in a pod.

Available client

K8s Discovery provides the client set for kubernetes client with hassle free configuration as well as the metrics client. The MetricsClientSet can be used to query the metrics against the containers. There is also a RestConfig exposed via discovery to make use of the rest api.

Example

package main

import (
	"context"
	"fmt"
	"log"
	"strconv"

	discovery "github.com/gkarthiks/k8s-discovery"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	metricsTypes "k8s.io/metrics/pkg/apis/metrics/v1beta1"
)

var (
	k8s *discovery.K8s
)

func main() {
	k8s, _ = discovery.NewK8s()
	namespace, _ := k8s.GetNamespace()
	version, _ := k8s.GetVersion()
	fmt.Printf("Specified Namespace: %s\n", namespace)
	fmt.Printf("Version of running Kubernetes: %s\n", version)
	
	
	
	
	cronJobs, err := k8s.Clientset.BatchV1beta1().CronJobs(namespace).List(context.Background(), metav1.ListOptions{})
	if err != nil {
		log.Panic(err.Error())
	}
	for idx, crons := range cronJobs.Items {
		fmt.Printf("%d -> %s\n", idx, crons.Name)
	}
	
	
	
	
	fmt.Println("==== Moving towards the metrics query ====")
	
	podMetrics, err := k8s.MetricsClientSet.MetricsV1beta1().PodMetricses(namespace).List(context.Background(), metav1.ListOptions{})
	if err != nil {
		panic(err)
	}

	var podMetric metricsTypes.PodMetrics
	getPodUsageMetrics := func(pod metricsTypes.PodMetrics) {
		for _, container := range pod.Containers {
			cpuQuantityDec := container.Usage.Cpu().AsDec().String()
			cpuUsageFloat, _ := strconv.ParseFloat(cpuQuantityDec, 64)

			fmt.Printf( "CPU Usage Float: %v\n", cpuUsageFloat)

			memoryQuantityDec := container.Usage.Memory().AsDec().String()
			memoryUsageFloat, _ := strconv.ParseFloat(memoryQuantityDec, 64)
			fmt.Printf("Memory Usage Float: %v\n\n", memoryUsageFloat)
		}
	}

	for _, podMetric = range podMetrics.Items {
		getPodUsageMetrics(podMetric)
	}
	
	
	
}

Note:

For GCP or managed kubernetes, you have to import the auth module, else an error message stating no Auth Provider found for name "gcp" will be thrown. The import looks like the below for the sample program. Special mention @ringods.

import (
	"context"
	"fmt"
	"log"
	"strconv"

	discovery "github.com/gkarthiks/k8s-discovery"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	metricsTypes "k8s.io/metrics/pkg/apis/metrics/v1beta1"
	_ "k8s.io/client-go/plugin/pkg/client/auth"
)

Contributing

For contributions please refer the contributing guidelines.

Documentation

Index

• type Env
• type K8s
  • func NewK8s() (*K8s, error)
  • func (o *K8s) CurrentContext() string
  • func (o *K8s) GetNamespace() (string, error)
  • func (o *K8s) GetVersion() (string, error)
  • func (o *K8s) IsDevEnv() bool
  • func (o *K8s) IsInKluster() bool

Types

type Env

type Env string

dev/production env detection, copied from Tilt

const (
	EnvUnknown       Env = "unknown"
	EnvGKE           Env = "gke"
	EnvMinikube      Env = "minikube"
	EnvDockerDesktop Env = "docker-for-desktop"
	EnvMicroK8s      Env = "microk8s"
	EnvCRC           Env = "crc"
	EnvKrucible      Env = "krucible"
	// Kind v0.6 substantially changed the protocol for detecting and pulling,
	// so we represent them as two separate envs.
	EnvKIND5          Env = "kind-0.5-"
	EnvKIND6          Env = "kind-0.6+"
	EnvK3D            Env = "k3d"
	EnvRancherDesktop Env = "rancher-desktop"
	EnvNone           Env = "none" // k8s not running (not neces. a problem, e.g. if using Tilt x Docker Compose)
)

type K8s

type K8s struct {
	Clientset        coreClient.Interface
	MetricsClientSet *metricsClient.Clientset
	RestConfig       *restClient.Config
	// contains filtered or unexported fields
}

K8s struct holds the instance of clientset and metrics clisentset

func NewK8s

func NewK8s() (*K8s, error)

NewK8s will provide a new k8s client interface resolves where it is running whether inside the kubernetes cluster or outside While running outside of the cluster, tries to make use of the kubeconfig file While running inside the cluster resolved via pod environment uses the in-cluster config

func (*K8s) CurrentContext

func (o *K8s) CurrentContext() string

func (*K8s) GetNamespace

func (o *K8s) GetNamespace() (string, error)

GetNamespace will return the current namespace for the running program Checks for the user passed ENV variable POD_NAMESPACE if not available pulls the namespace from pod, if not returns ""

func (*K8s) GetVersion

func (o *K8s) GetVersion() (string, error)

GetVersion returns the version of the kubernetes cluster that is running

func (*K8s) IsDevEnv

func (o *K8s) IsDevEnv() bool

func (*K8s) IsInKluster

func (o *K8s) IsInKluster() bool