初识 Client-go

最新推荐文章于 2024-05-26 21:50:28 发布
最新推荐文章于 2024-05-26 21:50:28 发布
阅读量302 收藏
点赞数
分类专栏： k8s与karmada 文章标签： golang kubernetes restful
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45747535/article/details/129831848
版权
文章介绍了RESTfulAPI作为前后端交互的规范，强调了其基于HTTP方法的资源操作特性。接着，文章详细讲解了Kubernetes中的Client-go库，包括RestClient、ClientSet、DynamicClient和DiscoveryClient，阐述了它们在操作Kubernetes资源时的不同作用和使用场景，展示了如何通过这些客户端进行资源的增删查改。
摘要由CSDN通过智能技术生成

在了解 Client-go 之前需要先理解一个概念叫 RESTful API

RESTful API

在主流公司的程序开发中，为了提高程序开发迭代的速度，基本都是前后端分离架构，而前端既包括网页、App、小程序等等，因此必须要有一个统一的规范用于约束前后端的通信，RESTful API则是目前比较成熟的API设计理论。

REST（Representational State Transfer）：表现层状态转移

RESTful是一种风格而不是标准，而这个风格大致有以下几个主要特征：

以资源为基础 ：资源可以是一个图片、音乐、一个XML格式、HTML格式或者JSON格式等网络上的一个实体，除了一些二进制的资源外普通的文本资源更多以JSON为载体、面向用户的一组数据(通常从数据库中查询而得到)。

统一接口: 对资源的操作包括获取、创建、修改和删除，这些操作正好对应HTTP协议提供的GET、POST、PUT和DELETE方法。换言而知，使用RESTful风格的接口但从接口上你可能只能定位其资源，但是无法知晓它具体进行了什么操作，需要具体了解其发生了什么操作动作要从其HTTP请求方法类型上进行判断。具体的HTTP方法和方法含义如下：

GET（SELECT）：从服务器取出资源（一项或多项）。
POST（CREATE）：在服务器新建一个资源。
PUT（UPDATE）：在服务器更新资源（客户端提供完整资源数据）。
PATCH（UPDATE）：在服务器更新资源（客户端提供需要修改的资源数据）。
DELETE（DELETE）：从服务器删除资源。

简单概括就是：RESTful 设计风格 可以让用户通过HTTP加不同的操作方式实现对资源的增删查改。

Client-go

Kubernetes就是经典的 RESTful 架构，用户可以轻松的通过GET、POST等方式访问、操作Kubernetes中的资源，例如Deployments、Pods、namespaces等。包括Kubectl命令其本质也是通过HTTP请求 kubernetes API Server 实现对资源的操作

通过 RESTful API 将前端和后端分离，用户可以直接的通过 HTTP 协议提交表单来对操作资源。但是频繁的填写表单对于开发人员来说并不是一种高效的的方式。

于是client-go应运而生（除此之位还有client-java、client-python等），client-go中封装了HTTP连接，使开发人员可以更高效的操作资源。

在这里插入图片描述
client-go中一共有四种客户端，分别是：

RestClient：

RestClient是最基础的客户端，其结构中包含 HTTP连接、URL链接、GroupVersion、以及编解码方式等参数。
在这里插入图片描述
使用RestClient之前需要了解几个基本的概念，以Deployment资源为例：
假设Deployment资源的路径是：
http://192.168.1.1:8001/apis/apps/v1/deployments

http://192.168.1.1:8001 就是 kubernetes 的 API Server 暴露出来的一个服务地址，通过这个服务地址，用户便可以和 API Server 建立连接。RestClient中的Client便相当于行驶建立连接这个过程，当然，Client还需要经过鉴权、认证等操作才可以建立连接，这里只是类比。

/apis 是最基础的api路径，除了apis外，还有api这个路径，pod、node、namespace等资源便在api路径下。

/apps/v1 这里的apps则是资源的Group，v1则是资源的Version，他们一起组成了GroupVersion，并注册到了Scheme中。

下面给出两个demo，分别是通过 RestClient 部署、删除namespace和deployment

func restOptNs() {
	var kubeconfig = "{KUBECONFIG PATH}"

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

	// 参考path : /api/v1/namespaces/{namespace}
	config.APIPath = "api"
	config.GroupVersion = &corev1.SchemeGroupVersion
	config.NegotiatedSerializer = scheme.Codecs

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

	ns := &corev1.Namespace{
		ObjectMeta: metav1.ObjectMeta{
			Name: "test-client-go",
		},
		Spec: corev1.NamespaceSpec{},
	}

	result := &corev1.Namespace{}
	err = restClient.Post().
		Resource("namespaces").
		Body(ns).
		Do(context.TODO()).
		Into(result)
	if err != nil {
		panic(err)
	}
	fmt.Printf("namespace %s created !\n", ns.Name)

	time.Sleep(time.Second * 20)
	
	err = restClient.Delete().
		Resource("namespaces").
		Name(ns.Name).
		Do(context.TODO()).
		Error()
	if err != nil {
		panic(err)
	}
	fmt.Printf("namespace %s deleted !\n", ns.Name)

}


func restK8sDeploy() {
	var kubeconfig = "{KUBECONFIG PATH}
	config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)

	if err != nil {
		panic(err.Error())
	}

	// 参考path : /api/apps/v1/namespaces/{namespace}/deployments
	config.APIPath = "apis"
	config.GroupVersion = &appsv1.SchemeGroupVersion
	config.NegotiatedSerializer = scheme.Codecs

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

	deploy := &appsv1.Deployment{}
	bytes, err := ioutil.ReadFile("./yamls/nginx.yaml")
	if err != nil {
		panic(err)
	}

	toJson, err := yaml.ToJSON(bytes)
	if err != nil {
		panic(err)
	}

	json.Unmarshal(toJson, deploy)

	
	var replicas int32 = 1
	deploy := &appsv1.Deployment{
	ObjectMeta: metav1.ObjectMeta{
			Name: "nginx",
			Labels: map[string]string{
	 			"app": "nginx",
	 		},
	 	},
	 	Spec: appsv1.DeploymentSpec{
	 		Replicas: &replicas,
	 		Selector: &metav1.LabelSelector{
	 			MatchLabels: map[string]string{
	 				"app": "nginx",
	 			},
	 		},
	 		Template: corev1.PodTemplateSpec{
	 			ObjectMeta: metav1.ObjectMeta{
	 				Name: "nginx",
	 				Labels: map[string]string{
	 					"app": "nginx",
	 				},
	 			},
	 			Spec: corev1.PodSpec{
	 				Containers: []corev1.Container{
	 					{
	 						Name:  "nginx",
	 						Image: "nginx:latest",
	 						Ports: []corev1.ContainerPort{
	 							{
	 								Name:          "http",
	 								Protocol:      corev1.ProtocolTCP,
									ContainerPort: 80,
	 							},
	 						},
	 					},
	 				},
	 			},
	 		},
	 	},
	 }

	err = restClient.Delete().
		Namespace(deploy.ObjectMeta.Namespace).
		Resource("deployments").
		Name(deploy.ObjectMeta.Name).
		Do(context.TODO()).
		Error()

	if err != nil {
		panic(err)
	}
	fmt.Printf("deployment %s deleted !\n", deploy.Name)
}

ClientSet

通过上文中的两个例子得知，在连接RestClient之前，需要配置基础路径（api、apis）以及资源的GroupVersion和编解码的方式，对于不同的资源（属于不同的GroupVersion）需要不同的配置，操作还是过于繁琐。
于是便出现了ClientSet，ClietSet实现了对RestClient的再封装。
在这里插入图片描述
其结构体中涵盖了所有的k8s资源，通过ClientSet，开发人员只需要建立一次连接，便可以通过不同的接口操作k8s中不同的资源，不用再重新定义GroupVersion、再重新建立连接。

func cliensetK8s() {
	var kubeconfig = "{KUBECONFIG PATH}"

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

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

	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(time.Second*100))
	defer cancel()

	listPod(clientset, ctx, "")
}

// 获取 Pod 列表
func listPod(clientset *kubernetes.Clientset, ctx context.Context, ns string) {
	pods, err := clientset.CoreV1().Pods("").List(ctx, metav1.ListOptions{})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("There are %d pods in the k8s cluster\n", len(pods.Items))

	// 获取指定 namespace 中的 Pod 列表信息
	namespace := ns
	pods, err = clientset.CoreV1().Pods(namespace).List(ctx, metav1.ListOptions{})
	if err != nil {
		panic(err)
	}
	fmt.Printf("\nThere are %d pods in namespaces %s\n", len(pods.Items), namespace)
	for _, pod := range pods.Items {
		// fmt.Printf("Name: %s, NameSpace: %s, Status: %s, CreateTime: %s\n", pod.ObjectMeta.Name, pod.ObjectMeta.Namespace, pod.Status.Phase, pod.ObjectMeta.CreationTimestamp)
		listPodInfo(clientset, ctx, pod.ObjectMeta.Namespace, pod.ObjectMeta.Name)
	}
}

func listPodInfo(clientset *kubernetes.Clientset, ctx context.Context, ns string, podName string) {
	namespace := ns
	pod, err := clientset.CoreV1().Pods(namespace).Get(ctx, podName, metav1.GetOptions{})

	if errors.IsNotFound(err) {
		fmt.Printf("Pod %s in namespace %s not found\n", podName, namespace)
	} else if statusError, isStatus := err.(*errors.StatusError); isStatus {
		fmt.Printf("Error getting pod %s in namespace %s: %v\n", podName, namespace, statusError.ErrStatus.Message)
	} else if err != nil {
		panic(err.Error())
	} else {
		fmt.Printf("\nFound pod %s in namespace %s\n", podName, namespace)
		maps := map[string]interface{}{
			"Name":        pod.ObjectMeta.Name,
			"Namespaces":  pod.ObjectMeta.Namespace,
			"NodeName":    pod.Spec.NodeName,
			"Annotations": pod.ObjectMeta.Annotations,
			"Labels":      pod.ObjectMeta.Labels,
			"Uid":         pod.ObjectMeta.UID,
			"Status":      pod.Status.Phase,
			"IP":          pod.Status.PodIP,
			"Image":       pod.Spec.Containers[0].Image,
		}
		prettyPrint(maps)
	}
}

在这里：

pods, err := clientset.CoreV1().Pods("").List(ctx, metav1.ListOptions{})

Pod 的 GroupVersion 便已经封装到了 .CoreV1() 接口中，从而简化了连接配置

DynamicClient

DynamicClient是一种动态客户端它可以对任何资源进行restful操作包括crd自定义资源，不同于 clientset，dynamic client 返回的对象是一个 map[string]interface{}，如果一个 controller 中需要控制所有的 API，可以使用dynamic client，目前它在 garbage collector 和 namespace controller中被使用。
DynamicClient的处理过程将Resource例如podlist转换为unstructured类型，k8s的所有resource都可以转换为这个结构类型，处理完之后在转换为podlist，整个转换过程类似于接口转换就是通过interface{}的断言。
Dynamic client 是一种动态的 client，它能处理 kubernetes 所有的资源，只支持JSON。

func dynamicK8s() {
	var kubeconfig = "{KUBECONFIG PATH}"
	config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
	if err != nil {
		panic(err)
	}

	dynamicClient, err := dynamic.NewForConfig(config)
	if err != nil {
		panic(err)
	}
	// 定义组版本资源
	gvr := schema.GroupVersionResource{Version: "v1", Resource: "pods"}
	unStructObj, err := dynamicClient.Resource(gvr).Namespace(namespace).List(metav1.ListOptions{})
	if err != nil {
		panic(err)
	}
	podList := &apiv1.PodList{}

	if err = runtime.DefaultUnstructuredConverter.FromUnstructured(unStructObj.UnstructuredContent(), podList); err != nil {
		panic(err)
	}

	for _, v := range podList.Items {
		fmt.Printf("namespaces:%v  name:%v status:%v \n", v.Namespace, v.Name, v.Status.Phase)
	}
}

DiscoverClient

DiscoveryClient是发现客户端，主要用于发现api server支持的资源组 资源版本 资源信息.

func discover() {

	var kubeconfig = "{KUBECONFIG PATH}"

	// 从本机加载kubeconfig配置文件，因此第一个参数为空字符串
	config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)

	// kubeconfig加载失败就直接退出了
	if err != nil {
		panic(err.Error())
	}

	// 新建discoveryClient实例
	discoveryClient, err := discovery.NewDiscoveryClientForConfig(config)

	if err != nil {
		panic(err.Error())
	}

	// 获取所有分组和资源数据
	APIGroup, APIResourceListSlice, err := discoveryClient.ServerGroupsAndResources()

	if err != nil {
		panic(err.Error())
	}

	// 先看Group信息
	fmt.Printf("APIGroup :\n\n %v\n\n\n\n", APIGroup)

	// APIResourceListSlice是个切片，里面的每个元素代表一个GroupVersion及其资源
	for _, singleAPIResourceList := range APIResourceListSlice {

		// GroupVersion是个字符串，例如"apps/v1"
		groupVerionStr := singleAPIResourceList.GroupVersion

		// ParseGroupVersion方法将字符串转成数据结构
		gv, err := schema.ParseGroupVersion(groupVerionStr)

		if err != nil {
			panic(err.Error())
		}

		fmt.Println("*****************************************************************")
		fmt.Printf("GV string [%v]\nGV struct [%#v]\nresources :\n\n", groupVerionStr, gv)

		// APIResources字段是个切片，里面是当前GroupVersion下的所有资源
		for _, singleAPIResource := range singleAPIResourceList.APIResources {
			fmt.Printf("%v\n", singleAPIResource.Name)
		}
	}
}

至此，四种Client-go客户端就已经介绍完毕

江城琉璃梦
关注
专栏目录
初识go-kratos
weixin_40899765的博客
04-25 323
api下新建test目录，执行kratos proto add api/test/service/v1/test.proto命令。15.app/test/service下新增internal/service文件夹。14.app/test/service下新增internal/server文件夹。12.app/test/service下新增internal/conf文件夹。13.app/test/service下新增internal/data文件夹。在ip下访问/test/create/123。
client-go学习笔记
xccheese
08-09 537
下载k8s1.14 git clone https://github.com/kubernetes/kubernetes.git cd $GOPATH/src/k8s.io/kubernetes git checkout -b release-1.14 remotes/origin/release-1.14 安装代码统计工具 yum install cloc 构建k8s makeormakeall本地构建 makerelease or make quick-releas...
client-go入门
Jacson__的博客
06-12 1791
client-go入门教程
k8s编程operator——(1) client-go基础部分
Peerless__的博客
11-11 4891
client-go是一个golang的client，我们可以通过client-go与K8S apiServer进行交互，对k8s集群中资源对象，包括内置资源（例如：Pod、Deployment、Service等）和CRD进行增删改查等操作。client-go地址目录结构：该包包含了可以访问kubernetes集群的api，通过这些API可以与apiServer进行通信，对集群的资源对象进行增删改查。
我敢说！你没见过这么细的client-go讲解
程序员溪昂
01-18 821
类似于kubectl命令，通过ClientSet列出所有运行中的Pod资源对象，ClientSet Example代码示例如下：运行以上代码，列出default命名空间下的所有Pod资源对象的相关信息。首先加载kubeconfig配置信息，kubernetes.NewForConfig通过kubeconfig配置信息实例化clientset对象，该对象用于管理所有Resource的客户端。
client-go入门之2：Job相关操作
祈晴小义
07-24 2243
文章目录 首先要获取一个连接k8s的*kubernetes.Clientset对象，具体连接方法参考：创建连接Kubernetes集群的客户端 创建Job的代码： import ( "fmt" v1 "k8s.io/api/batch/v1" corev1 "k8s.io/api/core/v1" "time" ) func CreateSimpleJob () { targetJob := &v1.Job{} targetJob.Namespace = "demo" // 所属的na
Client-go学习（1）
passnetY的博客
08-05 596
client-go
client-go系列之1---client-go代码结构讲解
gzhouc的专栏
10-13 1273
目录1. 写在前面2. 代码结构3. 代码使用简单示例3.1 获取kubeconfig及context3.2 创建ClientSet3.3 使用ClientSet获取集群中的pods3.4 使用ClientSet获取指定的pod4. 各种Clients详解5. 其它组件5.1 Reflector5.2 Informer5.3 Indexer5.4 WorkQueue 1. 写在前面 个人主页: https://gzh.readthedocs.io 关注容器技术、关注Kubernetes。问题或建议，请公众
初识docker -- 从版本历史、架构到安装
老猫的专栏
10-29 3058
目录 一、Docker的版本变迁 二、Docker 的组成架构 三、Docker的安装 一、Docker的版本变迁 自从dotCloud公司开源其Docker项目后，凭借其便捷的Docker镜像技术解决了当时困扰众多PaaS项目的难题：如何为应用打包，让用户将本地的应用顺利迁移到PaaS平台，而不用顾忌应用的开发语言、配置、依赖包等诸多因素，也因此开启了全新的Docker容器时代。 ...
初识gRPC及其在Go语言中的应用
# 1. 介绍gRPC ## 1.1 gRPC概述 在现代分布式系统中，gRPC是一种高性能、...通过IDL（接口定义语言）定义服务，生成客户端和服务器端的代码，减少了手动编写代码的工作量。 ## 1.3 gRPC与传统RESTful API的比较 gRPC
【GO+Iris】Iris框架初识
码农印象
11-16 6212
前言关于Iris安装IrisHostHTTP/2和安全任意iris.Runnerhost配置多个主机优雅的关闭带有TLS地自动公共域名app.Run的第二个参数使用配置自定义值从Context中访问配置Iris 进阶学习教程: 关于Iris Iris是一个通过GO编写的快速的，简单的，但是功能齐全和非常有效率的web框架 Iris为你下一个网站或者API提供一个精美的、使用简单的基础 Iris为使用者提供了一个完整且体面地支持 安装Iris Iris是一个跨平台的软件 //安装 //go get
彻底搞懂 etcd 系列文章（三）：etcd 集群运维部署
aoho求索
06-07 1430
0 专辑概述etcd 是云原生架构中重要的基础组件，由 CNCF 孵化托管。etcd 在微服务和 Kubernates 集群中不仅可以作为服务注册与发现，还可以作为 key-value ...
使用 client-go 对 Kubernetes 进行自定义开发及源码分析
哎_小羊的博客
12-03 5903
client-go 是一种能够与 Kubernetes 集群通信的客户端，通过它可以对 Kubernetes 集群中各资源类型进行 CRUD 操作，它有三大 client 类，分别为：Clientset、DynamicClient、RESTClient。通过它，我们可以很方便的对 Kubernetes 集群 API 进行自定义开发，来满足个性化需求。本文介绍如何使用 client-go 对 k8s 集群进行自定义开发及源码分析。
client-go组件详解
qq_34814562的博客
04-22 1413
client类型 informer机制 client类型 1.RestClient：最基础的，相当于底层数据结构，可以通过RestClient提供的RestFul方法，如Get()，Put()，Post(),Delete(),进行交互 同时支持json和protobuf 支持所有的原生资源和CRDs 但是一般而言，为了更为优雅的处理，需要进一步封装RestCLient为ClientSet，然后对外提供接口和服务 2.CleintSet：是调用kubernetes资源对象最常用的client，可以操作.
client-go实战之一：准备工作
程序员欣宸的博客
02-19 8406
client-go是操作kubernetes资源的常用工具，从本篇开始，咱们一起来学习这个重要的技能吧
client-go架构与原理介绍
qq_42009262的博客
06-01 1820
下面对图中每个组件进行简单介绍：​client-go 组件：Reflector: 定义在/tools/cache 包内的 Reflector 类型中的 reflector 监视 Kubernetes API 以获取指定的资源类型 (Kind)。完成此操作的函数是 ListAndWatch。监视可以用于内建资源，也可以用于自定义资源。
client-go源码
wxd1234567890的博客
12-09 1258
客户端 RESTClient RESTClient是最基础的，相当于的底层基础结构，可以直接通过 是RESTClient提供的RESTful方法如Get()，Put()，Post()，Delete()进行交互。同时支持Json 和 protobuf。支持所有原生资源和crd，但是一般不用，为了更为优雅的处理，需要进一步封装，通过Clientset封装RESTClient，然后再对外提供接口和服务 Clientset Clientset是调用Kubernetes资源对象最常用的client，可以操作所有的资源
kubernetes client-go功能介绍
最新发布
daemon365的博客
05-26 433
lister则是对indexer的封装，提供了一种简单的方式来获取已经索引的对象列表，以供代码中的其他部分使用。例如，Deployment 的 GVR 为 “apps/v1/deployments”，其中 “apps” 是 API 群组，“v1” 是 API 版本，“deployments” 是资源类型。Kubernetes的所有资源都可以转换为这个结构类型。总之，Lister作为client-go包中的一个重要组件，可以帮助开发者更加高效地处理Kubernetes资源对象，提高代码的可读性和可重用性。
云原生爱好者周刊：client-go 示例大全
KubeSphere
07-12 430
开源项目推荐 Kubernetes client-go examples 本仓库提供了非常详尽的 client-go 使用案例，非常适合 client-go 初学者。 TripleCross TripleCross 是一个 Linux eBPF rootkit，展示了 eBPF 技术的攻击能力。 这是一个学生的学士论文，拥有非常完整的设计文档、技术原理、任务管理甘特图等等，产品功能设计的比较复杂，功能比较完善，对 eBPF 感兴趣的小伙伴可以研究一下。 文章推荐 为 KubeSphere 集群启用免费的泛
初识uni-app框架
10-08
初识uni-app框架，可以从以下几个方面入手： 1. 开发环境准备：首先，需要安装Node.js环境和HBuilderX开发工具，Node.js用于运行JavaScript代码，HBuilderX是uni-app的开发工具。 2. 项目搭建：在HBuilderX中创建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值