源码参考地址：

https://github.com/kubernetes/client-go

???

组件简介：

~kubernetes 目录包含了所有访问k8s api的clientset。

~INFORMER 包含了所有类似的资源的INFORMER，便于操作k8s的资源对象。

~listers 包含了所有内置资源的lister，用于读取缓存中的k8s资源对象的信息。

~discovery 用于发现api server支持的api，比如kubectl api-versions就使用了该机制。

~dynamic 目录包含了dynamic client的逻辑，通过dynamic client可以操作任意的k8s的api对象，包括我们自定义的以及内置的k8s资源对象。

~plugin/pkg/client/auth 包含的所有的可选的认证插件，用于从外部获取credential。

~transport 包含了创建链接和认证的逻辑，它会被上层的clientset使用。

~tools 包含了一系列的工具，在编写控制器的时候会使用到这里面提供的一些工具方法。

• //go mod init client-go-demo
• //go get k8s.io/client-go@v0.19.15 #按需修改版本号下载

演示案例练习

package main

import (
	"context"
	"fmt"
	metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/tools/clientcmd"
)

func get_kube_ifo()  {
	configPath := "etc/config"
	config , err := clientcmd.BuildConfigFromFlags("",configPath)
	if err != nil {
		panic(err)
	}
	clientset , err := kubernetes.NewForConfig(config)
	if err != nil {
		panic(err)
	}

	//获取node信息
	nodeList ,err := clientset.CoreV1().Nodes().List(context.TODO(),metaV1.ListOptions{})
	if err != nil {
		panic(err)
	}
	fmt.Println("node:")
	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.Format("2006/01/02 15:04:05"),
		)
	}
	//获取namespace
	NamespaceList, err := clientset.CoreV1().Namespaces().List(context.TODO(),metaV1.ListOptions{})
	if err != nil {
		panic(err)
	}
	fmt.Println("\nnamespace:")
	for _,namespace := range NamespaceList.Items{
		fmt.Println(namespace.Name,"\t",namespace.CreationTimestamp.Format("2006/01/02 15:04:05"),"\t",namespace.Status.Phase)
	}
	
	//获取service
	ServiceList, err := clientset.CoreV1().Services("").List(context.TODO(),metaV1.ListOptions{})
	fmt.Println("\nservers:")
	for _,service := range ServiceList.Items{
		fmt.Println(service.Namespace,"\t",service.Name,"\t",service.Spec.Type,"\t",service.CreationTimestamp.Format("2006/01/02 15:04:05"),"\t",service.Spec.ClusterIP,"\t",service.Spec.Ports)
	}
	
	//获取deployment
	DeploymentList, err := clientset.AppsV1().Deployments("").List(context.TODO(),metaV1.ListOptions{})
	fmt.Println("\ndeployment:")
	for _,deployment := range DeploymentList.Items{
		fmt.Println(deployment.Namespace,"\t",
			deployment.Name,"\t",deployment.Labels,"\t",
			deployment.Spec.Selector.MatchLabels,"\t",
			deployment.CreationTimestamp.Format("2006/01/02 15:04:05"),"\t",
			deployment.Status.AvailableReplicas,"/",deployment.Status.Replicas)
	}

}


func main(){
	get_kube_ifo()
}

效果

===========================================================================
node:
master01	 [{InternalIP 192.168.59.131} {Hostname master01}] 	 CentOS Linux 7 (Core) 	 v1.16.2 	 linux 	 amd64 	 2021/11/20 00:09:41,
node01	 	 [{InternalIP 192.168.59.130} {Hostname node01}] 	 CentOS Linux 7 (Core) 	 v1.16.2 	 linux 	 amd64 	 2021/11/20 00:10:04,
node02	 	 [{InternalIP 192.168.59.132} {Hostname node02}] 	 CentOS Linux 7 (Core) 	 v1.16.2 	 linux 	 amd64 	 2021/11/20 00:10:07,

namespace:
default 	 2021/11/20 00:09:43 	 Active
kube-node-lease 	 2021/11/20 00:09:41 	 Active
kube-public 	 2021/11/20 00:09:41 	 Active
kube-system 	 2021/11/20 00:09:41 	 Active

servers:
default 	 kubernetes 	 ClusterIP 	 2021/11/20 00:09:43 	 10.10.0.1 	 [{https TCP <nil> 443 {0 6443 } 0}]
default 	 my-nginx 	 NodePort 	 2021/11/20 11:46:06 	 10.10.86.227 	 [{ TCP <nil> 80 {0 80 } 31868}]
default 	 mygin-k8s 	 NodePort 	 2021/11/22 10:19:32 	 10.10.11.253 	 [{ TCP <nil> 8000 {0 8000 } 30956}]
default 	 tomcat 	 NodePort 	 2021/11/20 11:27:04 	 10.10.95.191 	 [{ TCP <nil> 8080 {0 8080 } 30795}]
kube-system 	 kube-dns 	 ClusterIP 	 2021/11/20 00:09:44 	 10.10.0.10 	 [{dns UDP <nil> 53 {0 53 } 0} {dns-tcp TCP <nil> 53 {0 53 } 0} {metrics TCP <nil> 9153 {0 9153 } 0}]

deployment:
default 	 gok8s-name 	 map[app:gok8s-name] 	 map[app:gok8s-name] 	 2021/11/21 00:41:11 	 0 / 1
default 	 my-nginx 	 map[app:my-nginx] 	 map[app:my-nginx] 	 2021/11/20 11:41:19 	 0 / 1
default 	 mygin-k8s 	 map[app:mygin-k8s] 	 map[app:mygin-k8s] 	 2021/11/22 10:12:06 	 0 / 1
default 	 tomcat 	 map[app:tomcat] 	 map[app:tomcat] 	 2021/11/20 00:29:08 	 0 / 1
kube-system 	 calico-kube-controllers 	 map[k8s-app:calico-kube-controllers] 	 map[k8s-app:calico-kube-controllers] 	 2021/11/20 00:10:12 	 1 / 1
kube-system 	 coredns 	 map[k8s-app:kube-dns] 	 map[k8s-app:kube-dns] 	 2021/11/20 00:09:44 	 2 / 2

进程 已完成，退出代码为 0

RESTClient原理

Client类型

• RESTClient：最基础的客户端，提供最基本的封装。
• Clientset：是一个client的集合，在Clientset中包含了所有k8s的内置资源的Client，通过Clientset可以很方便的操作如pod，Service，deployment等资源。
• dynamicClient：动态客户端，可以操作任何K8S的资源，包括CRD定义的资源。
• DiscoveryClient：用于发现K8S提供的资源组，资源版本和资源信息，比如kubectl api-resources

RESTClient的使用

• RESTClientFor：为创建RESTClient准备config，比如限速器，编解码器等。
• UnversionedRESTClientFor：与RESTClientFor类似，只是允许config.GroupVersion为空。

    // config
	config , err := clientcmd.BuildConfigFromFlags("","kube/config")
	if err != nil {
		panic(err)
	}

	//client
	restClient ,err := rest.RESTClientFor(config)
	if err != nil {
		panic(err)
	}

Clientset的使用

    ...

	config , err := clientcmd.BuildConfigFromFlags("","kube/config")
	if err != nil {
		panic(err)
	}
	clientset , err := kubernetes.NewForConfig(config)
	if err != nil {
		panic(err)
	}

   //对象的AppV1或者CoreV1等版本通过kubectl api-resources查看
  appv1 := clientset.AppsV1()
	deploymentsClient := appv1.Deployments("Default").List()
                                        Create()/ Delete()/Get()

    ...

dynamicClient的使用

	config , err := clientcmd.BuildConfigFromFlags("","kube/config")
	if err != nil {
		panic(err)
	}
	client, err := dynamic.NewForConfig(config)
	if err != nil {
		panic(err)
	}

DiscoveryClient的使用：

	config , err := clientcmd.BuildConfigFromFlags("","kube/config")
	if err != nil {
		panic(err)
	}
	client, err := discovery.NewDiscoveryClientForConfig(config)
	if err != nil {
		panic(err)
	}

另外还有两个DiscoveryClient，分别支持将数据缓存在磁盘文件或者内存当中。

?