go 调用 k8s的api

官网：https://github.com/kubernetes-client/go/tree/master/kubernetes

https://github.com/kubernetes/client-go
https://github.com/kubernetes/client-go/tree/v0.21.0
https://pkg.go.dev/k8s.io/client-go/kubernetes

go mod init k8sclient

go get k8s.io/client-go/kubernetes@v0.21.0
go get k8s.io/client-go@v0.21.0


kubectl api-resources

代码展示

package main

import (
    "context"
    "fmt"
    appsV1 "k8s.io/api/apps/v1"
    coreV1 "k8s.io/api/core/v1"
    metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
    "log"
    "reflect"
)

func Createdeployment(clientset *kubernetes.Clientset)  {
    var replicas int32 =1
    namespace := "enos"
    deployment := &appsV1.Deployment{
        ObjectMeta: metaV1.ObjectMeta{
            Name: "nginx",
            Labels: map[string]string{
                "app":"nginx",
                "env":"dev",
            },
        },
        Spec: appsV1.DeploymentSpec{
            Replicas: &replicas,
            Selector: &metaV1.LabelSelector{
                MatchLabels: map[string]string{
                    "app":"nginx",
                    "env":"dev",
                },
            },
            Template: coreV1.PodTemplateSpec{
                ObjectMeta: metaV1.ObjectMeta{
                    Name: "nginx",
                    Labels: map[string]string{
                        "app": "nginx",
                        "env": "dev",
                    },
                },
                Spec: coreV1.PodSpec{
                    Containers: []coreV1.Container{
                        {
                            Name: "nginx",
                            Image: "nginx:1.16.1",
                            Ports: []coreV1.ContainerPort{
                                {
                                    Name: "http",
                                    Protocol: coreV1.ProtocolTCP,
                                    ContainerPort: 80,
                                },
                            },
                        },
                    },
                },
            },
        },
    }
    deployment1,err := clientset.AppsV1().Deployments(namespace).Create(context.TODO(),deployment,metaV1.CreateOptions{})
    fmt.Println(err,deployment1)
}

func CreateService(clientset *kubernetes.Clientset)  {
    namespace := "default"
    service := &coreV1.Service{
        ObjectMeta: metaV1.ObjectMeta{
            Name: "nginx-service",
            Labels: map[string]string{
                "env":"env",
            },
        },
        Spec: coreV1.ServiceSpec{
            Type: coreV1.ServiceTypeNodePort,
            Selector: map[string]string{
                "env":"dev",
                "app":"nginx",
            },
            Ports: []coreV1.ServicePort{
                {
                    Name: "http",
                    Port: 80,
                    Protocol: coreV1.ProtocolTCP,
                },
            },
        },
    }
    service1,err := clientset.CoreV1().Services(namespace).Create(context.TODO(),service,metaV1.CreateOptions{})
    fmt.Println(service1,err)
}

func editdeployment(clientset *kubernetes.Clientset)  {
    name :="nginx"
    namespace:="enos"
    var replicas int32 =2

    deployment,err := clientset.AppsV1().Deployments(namespace).Get(context.TODO(),name,metaV1.GetOptions{})
    deployment.Spec.Replicas = &replicas
    deployment.Spec.Template.Spec.Containers[0].Image = "nginx:1.14"
    deployment,err = clientset.AppsV1().Deployments(namespace).Update(context.TODO(),deployment,metaV1.UpdateOptions{})
    fmt.Println(err,deployment)
}

func editscaledeployment(clientset *kubernetes.Clientset) {
    name :="nginx"
    namespace:="enos"
    scale,_ := clientset.AppsV1().Deployments(namespace).GetScale(context.TODO(),name,metaV1.GetOptions{})
    //fmt.Println(err)
    scale.Spec.Replicas = 1
    scale,_ = clientset.AppsV1().Deployments(namespace).UpdateScale(context.TODO(),name,scale,metaV1.UpdateOptions{})
}

func deleteDeployment(clientset *kubernetes.Clientset)  {
    name :="nginx"
    namespace:="enos"
    clientset.AppsV1().Deployments(namespace).Delete(context.TODO(),name,metaV1.DeleteOptions{})
}

func deleteService(clientset *kubernetes.Clientset)  {
    namespace := "default"
    servicename:= "nginx-service"
    clientset.CoreV1().Services(namespace).Delete(context.TODO(),servicename,metaV1.DeleteOptions{})
}

func main()  {
    configPath := "conf/kube.conf"
    config,err := clientcmd.BuildConfigFromFlags("",configPath)
    if err != nil {
        log.Fatal(err)
    }
    clientset,err := kubernetes.NewForConfig(config)
    if err != nil {
        log.Fatal(err)
    }
    nodeList,err := clientset.CoreV1().Nodes().List(context.TODO(),metaV1.ListOptions{})
    if err != nil {
        log.Fatal(err)
    }
    for _,node := range nodeList.Items{
        fmt.Printf("%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n",
            node.Name,
            node.Status.Phase,
            node.Status.Addresses,
            node.Status.NodeInfo.OSImage,
            node.Status.NodeInfo.KubeletVersion,
            node.Status.NodeInfo.OperatingSystem,
            node.Status.NodeInfo.Architecture,
            node.CreationTimestamp,
            )
    }

    fmt.Println("=====Namespaces==============")
    namespaceList,_ := clientset.CoreV1().Namespaces().List(context.TODO(),metaV1.ListOptions{})
    for _,namespace := range namespaceList.Items {
        fmt.Println(namespace.Name,namespace.CreationTimestamp,namespace.Status.Phase)
    }
    fmt.Println("=====Service==============")
    // 名称空间传空，默认所以
     servicesList,_ := clientset.CoreV1().Services("").List(context.TODO(),metaV1.ListOptions{})

    for _,service := range servicesList.Items {
        fmt.Println(service.Name,service.Spec.Type,service.CreationTimestamp,service.Spec.ClusterIP,service.Spec.Ports)
    }
    fmt.Println("=====deployments==============")
    deploymentList,_ := clientset.AppsV1().Deployments("").List(context.TODO(),metaV1.ListOptions{})
    for _,deployment := range deploymentList.Items {
        fmt.Println(deployment.Namespace,deployment.Name,deployment.Spec.Selector.MatchLabels,deployment.Status.Replicas,deployment.Status.AvailableReplicas)
    }

    fmt.Println("zifu 的数据类型是:",reflect.TypeOf(clientset))

    //    create deployment
    // Createdeployment(clientset)

    // create service
    //CreateService(clientset)

    // editdeployment
    //editdeployment(clientset)
    //editscaledeployment(clientset)

    // deleteDeployment
    //deleteDeployment(clientset)
    deleteService(clientset)

    //扩展 ingress
    //clientset.ExtensionsV1beta1().Ingresses()
}

 获取链接的另一种

package main

import (
    "context"
    "flag"
    "fmt"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/client-go/util/homedir"
    "k8s.io/klog"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

    "path/filepath"
)

func main()  {
    var kubeConfig *string
    ctx := context.Background()
    if home := homedir.HomeDir(); home != "" {
        kubeConfig = flag.String("kubeConfig",filepath.Join(home,".kube","config"),"absolute path to the kubeConfig file")
    } else {
        kubeConfig = flag.String("kubeConfig","","absolute path to the kubeConfig file")
    }
    flag.Parse()
    config,err := clientcmd.BuildConfigFromFlags("",*kubeConfig)
    if err != nil {
        klog.Fatal(err)
        return
    }
    clientSet,err := kubernetes.NewForConfig(config)
    if err != nil {
        klog.Fatal(err)
        return
    }
    namespaceList,err:=clientSet.CoreV1().Namespaces().List(ctx,metav1.ListOptions{})
    if err != nil {
        return
    }
    namespaces := namespaceList.Items
    for _,ns := range namespaces {
        fmt.Println(ns.Name)
    }
}

 

监听事件（Informers）

依赖

module Informers

go 1.16

require (
    k8s.io/api v0.23.4 // indirect
    k8s.io/apimachinery v0.23.4 // indirect
    k8s.io/client-go v0.22.0 // indirect
    k8s.io/klog v1.0.0 // indirect
)

代码

package main

import (
    "fmt"
    "k8s.io/client-go/informers"
    "k8s.io/api/apps/v1"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/cache"
    "k8s.io/apimachinery/pkg/labels"
    "k8s.io/klog"

    "time"
)

func main()  {
    conf := ""
    clientSet,err := kubernetes.NewForConfig(conf)
    if err != nil {
        panic(err)
        return
    }
    informerFactory := informers.NewSharedInformerFactory(clientSet,30*time.Second)
    deployInformer := informerFactory.Apps().V1().Deployments()
    informer := deployInformer.Informer()
    deployLister:= deployInformer.Lister()
    informer.AddEventHandler(cache.ResourceEventHandlerFuncs{
        AddFunc: onAdd,
        UpdateFunc: onUpdate,
        DeleteFunc: onDelete,

    })
    stopper := make(chan struct{})
    defer close(stopper)
    //启动Informer List & Watch
    informerFactory.Start(stopper)
    // 等待所有的Informer缓存同步
    informerFactory.WaitForCacheSync(stopper)
    deployments,err:=deployLister.Deployments("default").List(labels.Everything())
    for index,deploy := range deployments {
        fmt.Printf("%d -> %s\n",index,deploy)
    }
    <-stopper
}

func onAdd(obj interface{})  {
    deploy := obj.(*v1.Deployment)
    klog.Infoln("add a deploy: ",deploy.Name)
}

func onUpdate(old,new interface{})  {
    oldDeploy:= old.(*v1.Deployment)
    newDeploy:= old.(*v1.Deployment)
    klog.Infoln("update deploy: ",oldDeploy.Spec.Replicas,newDeploy.Spec.Replicas)
}

func onDelete(obj interface{})  {
    deploy := obj.(*v1.Deployment)
    klog.Infoln("delete a deploy: ",deploy.Name)
}