通过client-go来操作K8S集群的操作方法_Golang

client-go

一、client-go介绍

1. 什么是client-go?

client-go是kubernetes官方提供的，用于操作kubernetes资源的go语言客户端库，通过它，开发者可以非常方便地在go项目中与kubernetes集群进行交互，实现对kubernetes资源以及自定义crd的增删改查和事件监听等操作。
同时，可以通过client-go实现kubernetes的二次开发。自定义资源开发。

源码：
github下载地址：https://github.com/kubernetes/client-go

如果是其他语言的客户端工具，可以通过https://github.com/kubernetes-client 来查看

我们看下client-go几个比较重要的目录

2. client-go版本的演变

左边是client-go的版本。右边是k8s的版本
在client-go 1.17版本之前，client-go的版本与k8s版本保持一致，1.17之后，client-go的版本多了一个v的tag。是由于go语言的包是带v的版本

建议：client-go我们直接用最新版本

3. client-go客户端分类

restclient: 一般我们不会使用restclient，因为它需要把整个资源的yaml文件或json数据都传过去，显得比较臃肿，一般我们不用这个
discoverclient: 比如我们创建deployment时的apiversion: apps/v1 apps就是资源组group v1就是资源版本version 资源信息就是kind 。我们一般也不会用这个客户端工具
clientset: 只能针对k8s内置的资源进行操作，不能操作自定义的资源
dyanmicclient：我们经常使用这个客户端，但是对于内置资源，我们还是习惯使用clientset，因为它更好用，自定义资源我们使用dyanmicclient。

我们可以通过命令 kubectl api-resources 查看每种资源的资源组

4. client-go客户端工具依赖关系

5. 安装client-go

client-go是一个go模块，可以通过go module的方式进行安装。在你的go项目中，执行以下命令：

go get k8s.io/client-go@latest

这将安装最新版本的client-go。此外，你还需要安装一些相关的依赖库，例如apimachinery，用于处理kubernetes api对象。

go get k8s.io/apimachinery@latest

安装完还需要运行go mod tidy 加载依赖包

二、使用client-go进行基本操作

创建kubernetes客户端
在使用client-go之前，首先需要创建一个kubernetes客户端。client-go提供了两种创建客户端的方式：in-cluster配置和out-of-cluster配置。

我们根据我们之前写好的脚手架，改个名字，在此基础上开发我们的项目

并不是说在此改了就可以了，因为很多包用的还是原来的名字，

我们可以批量替换
在goland ide中想要替换某一段特定的字符串，可以使用find and replace 功能来实现。这是一种全局性的操作，将会在你的整个项目或指定的文件/文件夹中进行。

使用ctrl + shift + r 打开find and repalce对话框

我们测试client-go，要用到k8s集群，得有~/.kube/config 这个文件
里面是加载集群的配置信息

将这个文件复制到我们的项目中

2.1 in-cluster配置

在kubernetes 集群内部运行时，可以使用in-cluster配置。这种方式不需要手动指定kubeconfig文件路径，client-go会自动使用集群中的服务账户进行身份验证。

2.2 out-of-cluster配置

测试client-go，我们使用out-of-cluster方式来测试，发布项目的时候，我们使用in-cluster方式配置
在本地电脑开发环境或其他非kubernetes集群中运行时，可以使用out-of-cluster配置。这需要指定kubeconfig文件的路径。kubeconfig文件通常位于$home/.kube/config，它包含了访问kubernetes集群所需的配置信息。

这是github上面看用法举例

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 main() {
    //1. 初始化config实例
    //var kubeconfig *string
    // 通过家目录找到kubeconfig文件。我们的路径是已知的，所以不用此项配置
    //if home := homedir.homedir(); home != "" {
    //    kubeconfig = flag.string("meta.kubeconfig", filepath.join(home, ".kube", "config"), "(optional) absolute path to the kubeconfig file")
    //} else {
    //    kubeconfig = flag.string("kubeconfig", "", "absolute path to the kubeconfig file")
    //}
    //flag.parse()
    // 1. 初始化config实例
    // 因为我们的路径是已知的，所以不用上面的配置。use the current context in kubeconfig
    // masterurl就是离我们主节点的ip地址和端口号，我们在kubeconfig文件中有了，所以可以省略
    config, err := clientcmd.buildconfigfromflags("", "meta.kubeconfig")
    //要想正常应用我们的服务，必须能够实例化成功kubeconfig，要不然后面所有的功能都无法使用，所以这里直接报panic即可
    if err != nil {
        panic(err.error())
    }
    // 2. 创建客户端工具 create the clientset
    clientset, err := kubernetes.newforconfig(config)
    //这个客户端工具如果生成失败的话，后面的操作也无法完成，所以这里也报panic即可
    if err != nil {
        panic(err.error())
    }
    //3. 操作集群
    pods, err := clientset.corev1().pods("").list(context.todo(), metav1.listoptions{})
    //此时报错的话，不应该是panic了，但是这里官方用的还是panic。后期需要优化，我么可以返回个错误信息
    if err != nil {
        panic(err.error())
    }
    //打印pod的数量
    fmt.printf("there are %d pods in the cluster\n", len(pods.items))
    // 获取指定名称空间下的pod数量，如果namespace不传值，默认查的是所有命名空间下的pod
    namespace := "h5-web"
    pods, err = clientset.corev1().pods(namespace).list(context.todo(), metav1.listoptions{})
    if err != nil {
        panic(err.error())
    }
    //打印pod的数量
    fmt.printf("%s namespce has %d pods in the cluster\n", namespace, len(pods.items))
    //看下返回的pod是什么
    fmt.println("pods是什么:", pods)
}

2.3 client-go 查询列表功能使用

我们看下list方法的参数，包含两个，一个context，一个是listoptions。

这个listoptions就可以在里面做些筛选条件，比如传json串，标签等

我们看下list的返回值

所以我们要查询具体的pod里面的信息，可以在items字段中获取到所有的pod
跟我们通过在k8s集群中通过kubectl … -ojson的得到的信息是一样的

如果要取其中某个pod，可以通过下标来获取

如果忘记pod的层级关系，可以使用k8s命令的-ojson 查看一下

完整代码：

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 main() {
    // 1. 初始化config实例
    // masterurl就是离我们主节点的ip地址和端口号，我们在kubeconfig文件中有了，所以可以省略
    config, err := clientcmd.buildconfigfromflags("", "meta.kubeconfig")
    //要想正常应用我们的服务，必须能够实例化成功kubeconfig，要不然后面所有的功能都无法使用，所以这里直接报panic即可
    if err != nil {
        panic(err.error())
    }
    // 2. 创建客户端工具 create the clientset
    clientset, err := kubernetes.newforconfig(config)
    //这个客户端工具如果生成失败的话，后面的操作也无法完成，所以这里也报panic即可
    if err != nil {
        panic(err.error())
    }
    //3. 操作集群
    pods, err := clientset.corev1().pods("").list(context.todo(), metav1.listoptions{})
    //此时报错的话，不应该是panic了，但是这里官方用的还是panic。后期需要优化，我么可以返回个错误信息
    if err != nil {
        panic(err.error())
    }
    //打印pod的数量
    fmt.printf("there are %d pods in the cluster\n", len(pods.items))
    // 获取指定名称空间下的pod数量，如果namespace不传值，默认查的是所有命名空间下的pod
    namespace := "h5-web"
    pods, err = clientset.corev1().pods(namespace).list(context.todo(), metav1.listoptions{})
    if err != nil {
        panic(err.error())
    }
    //打印pod的数量
    fmt.printf("%s namespce has %d pods in the cluster\n", namespace, len(pods.items))
    //看下返回的pod是什么
    fmt.println("pods是什么:", pods)
    //获取到某个pod
    fmt.println(pods.items[0].spec.nodename)
    //获取到某个容器的镜像
    fmt.println(pods.items[0].spec.containers[0].image)
}

下面，我们探讨下，我们怎么知道我们要操作的资源是属于corev1()或者是其他什么组呢？
之前，我们说过，在k8s集群中，可以通过命令 kubectl api-resources查看

deployment 的apiversion是 apps/v1 对应的client-go里面的方法就是 clientset.appsv1()
crontabs 的apiversion是batch/v1 对应的client-go里面的方法就是clientset.batchv1()
ingresses的apiversion是networking.k8s.io/v1 对应client-go里面的方法就是clientset.networkingv1()
…
以此类推，由此我们就知道了个汇总资源对应的操作方法
这种v1的apiversion的资源，对应的就是clientset.corev1()

如果不想通过k8s命令来查，也可以在代码中查看
点进来

这里可看看到个各种方法，不过我们用的时候要把首字母大写

比如查询deployment

//查询deployment列表,用法与pod类似
deploy, _ := clientset.appsv1().deployments("").list(context.todo(), metav1.listoptions{})
//查看所有名称空间下deploy的数量
fmt.println("deployment的数量", len(deploy.items))
//打印deploy名称,由于是多个，我们循环打印
for _, i := range deploy.items {
    fmt.printf("当前资源的名称空间: %s, deployment名称是: %s\n", i.namespace, i.name)
}
//查询没有名称空间限制的资源,比如名称空间，工作节点，clusterrole，clusterrolebinding等
//查的都是集群的资源
//比如我们查询集群有多少个名称空间
ns, _ := clientset.corev1().namespaces().list(context.todo(), metav1.listoptions{})
fmt.printf("there are %d namespaces in the cluster\n", len(ns.items))

完整代码：

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 main() {
    // 1. 初始化config实例
    // masterurl就是离我们主节点的ip地址和端口号，我们在kubeconfig文件中有了，所以可以省略
    config, err := clientcmd.buildconfigfromflags("", "meta.kubeconfig")
    //要想正常应用我们的服务，必须能够实例化成功kubeconfig，要不然后面所有的功能都无法使用，所以这里直接报panic即可
    if err != nil {
        panic(err.error())
    }
    // 2. 创建客户端工具 create the clientset
    clientset, err := kubernetes.newforconfig(config)
    //这个客户端工具如果生成失败的话，后面的操作也无法完成，所以这里也报panic即可
    if err != nil {
        panic(err.error())
    }
    //3. 操作集群
    pods, err := clientset.corev1().pods("").list(context.todo(), metav1.listoptions{})
    //此时报错的话，不应该是panic了，但是这里官方用的还是panic。后期需要优化，我么可以返回个错误信息
    if err != nil {
        panic(err.error())
    }
    //打印pod的数量
    fmt.printf("there are %d pods in the cluster\n", len(pods.items))
    // 获取指定名称空间下的pod数量，如果namespace不传值，默认查的是所有命名空间下的pod
    //namespace := "h5-web"
    //pods, err = clientset.corev1().pods(namespace).list(context.todo(), metav1.listoptions{})
    //if err != nil {
    //    panic(err.error())
    //}
    打印pod的数量
    //fmt.printf("%s namespce has %d pods in the cluster\n", namespace, len(pods.items))
    看下返回的pod是什么
    //fmt.println("pods是什么:", pods)
    //
    获取到某个pod
    //fmt.println(pods.items[0].spec.nodename)
    获取到某个容器的镜像
    //fmt.println(pods.items[0].spec.containers[0].image)
    //查询deployment列表,用法与pod类似
    deploy, _ := clientset.appsv1().deployments("").list(context.todo(), metav1.listoptions{})
    //查看所有名称空间下deploy的数量
    fmt.println("deployment的数量", len(deploy.items))
    //打印deploy名称,由于是多个，我们循环打印
    for _, i := range deploy.items {
        fmt.printf("当前资源的名称空间: %s, deployment名称是: %s\n", i.namespace, i.name)
    }
    //查询没有名称空间限制的资源,比如名称空间，工作节点，clusterrole，clusterrolebinding等
    //查的都是集群的资源
    //比如我们查询集群有多少个名称空间
    ns, _ := clientset.corev1().namespaces().list(context.todo(), metav1.listoptions{})
    fmt.printf("there are %d namespaces in the cluster\n", len(ns.items))
}

2.4 client-go查询资源详情

get()方法，可以获取单个资源的详情，获取详情之后，我们可以传给前端展示，或者根据查询出来的数据进行更改
比如说，我们对k8s集群中h5-web名称空间下的 pods 查询详情

// 查询资源详情 get()方法
// get(ctx context.context, name string, opts metav1.getoptions) (*v1.pod, error)
poddetail, _ := clientset.corev1().pods("h5-web").get(context.todo(), "web-864f4c6988-95sw4", metav1.getoptions{})
//fmt.println("pod详情:", poddetail)
//打印pod的镜像名称
fmt.println("pod第一个容器的镜像名称", poddetail.spec.containers[0].image)
//获取名称空间的详情
namespace, _ := clientset.corev1().namespaces().get(context.todo(), "h5-web", metav1.getoptions{})
fmt.println("名称空间详情:", namespace)

完整代码

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 main() {
    // 1. 初始化config实例
    // masterurl就是离我们主节点的ip地址和端口号，我们在kubeconfig文件中有了，所以可以省略
    config, err := clientcmd.buildconfigfromflags("", "meta.kubeconfig")
    //要想正常应用我们的服务，必须能够实例化成功kubeconfig，要不然后面所有的功能都无法使用，所以这里直接报panic即可
    if err != nil {
        panic(err.error())
    }
    // 2. 创建客户端工具 create the clientset
    clientset, err := kubernetes.newforconfig(config)
    //这个客户端工具如果生成失败的话，后面的操作也无法完成，所以这里也报panic即可
    if err != nil {
        panic(err.error())
    }
    //3. 操作集群
    // 查询资源详情 get()方法
    // get(ctx context.context, name string, opts metav1.getoptions) (*v1.pod, error)
    poddetail, _ := clientset.corev1().pods("h5-web").get(context.todo(), "web-864f4c6988-95sw4", metav1.getoptions{})
    //fmt.println("pod详情:", poddetail)
    //打印pod的镜像名称
    fmt.println("pod第一个容器的镜像名称", poddetail.spec.containers[0].image)
    //获取名称空间的详情
    namespace, _ := clientset.corev1().namespaces().get(context.todo(), "h5-web", metav1.getoptions{})
    fmt.println("名称空间详情:", namespace)
}

其他资源查询方式类似，感兴趣的朋友可以尝试下

2.5 client-go更新资源功能

更新的前提是该字段是可更改的
比如这种can’t be updated的字段，就不能被修改

注意：如果修改的字段在资源中不存在，比如labels 。修改时会报空指针错误，此时就要初始化下才能修改

//更新资源操作  update()
//先获取资源详情，再修改
//比如，我们修改service的暴露的端口号
service, _ := clientset.corev1().services("h5-web").get(context.todo(), "web", metav1.getoptions{})
fmt.printf("service对外的端口号是 %d\n", service.spec.ports[0].nodeport)
// 修改端口号
// service-node-port-range 默认可以设置的范围 30000-32767
service.spec.ports[0].nodeport = 32050
// 修改暴露的端口号
// update(ctx context.context, service *v1.service, opts metav1.updateoptions) (*v1.service, error)
_, err = clientset.corev1().services("h5-web").update(context.todo(), service, metav1.updateoptions{})
if err != nil {
    panic(err.error())
}
fmt.printf("修改后service对外的端口号是 %d\n", service.spec.ports[0].nodeport)
//修改deploy的副本数
deploy, _ := clientset.appsv1().deployments("h5-web").get(context.todo(), "web", metav1.getoptions{})
//查看当前deploy的副本数
fmt.println("当前deploy的副本数是:", *deploy.spec.replicas)
//修改副本数
replacs := int32(3)
//注意replicas 是int32的指针类型
deploy.spec.replicas = &replacs
_, err = clientset.appsv1().deployments("h5-web").update(context.todo(), deploy, metav1.updateoptions{})
//查看修改后deploy的副本数
fmt.println("修改后deploy的副本数是:", *deploy.spec.replicas)

完整代码：

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 main() {
    // 1. 初始化config实例
    // masterurl就是离我们主节点的ip地址和端口号，我们在kubeconfig文件中有了，所以可以省略
    config, err := clientcmd.buildconfigfromflags("", "meta.kubeconfig")
    //要想正常应用我们的服务，必须能够实例化成功kubeconfig，要不然后面所有的功能都无法使用，所以这里直接报panic即可
    if err != nil {
        panic(err.error())
    }
    // 2. 创建客户端工具 create the clientset
    clientset, err := kubernetes.newforconfig(config)
    //这个客户端工具如果生成失败的话，后面的操作也无法完成，所以这里也报panic即可
    if err != nil {
        panic(err.error())
    }
    //3. 操作集群
    //更新资源操作  update()
    //先获取资源详情，再修改
    //比如，我们修改service的暴露的端口号
    service, _ := clientset.corev1().services("h5-web").get(context.todo(), "web", metav1.getoptions{})
    fmt.printf("service对外的端口号是 %d\n", service.spec.ports[0].nodeport)
    // 修改端口号
    // service-node-port-range 默认可以设置的范围 30000-32767
    service.spec.ports[0].nodeport = 32050
    // 修改暴露的端口号
    // update(ctx context.context, service *v1.service, opts metav1.updateoptions) (*v1.service, error)
    _, err = clientset.corev1().services("h5-web").update(context.todo(), service, metav1.updateoptions{})
    if err != nil {
        panic(err.error())
    }
    fmt.printf("修改后service对外的端口号是 %d\n", service.spec.ports[0].nodeport)
    //修改deploy的副本数
    deploy, _ := clientset.appsv1().deployments("h5-web").get(context.todo(), "web", metav1.getoptions{})
    //查看当前deploy的副本数
    fmt.println("当前deploy的副本数是:", *deploy.spec.replicas)
    //修改副本数
    replacs := int32(3)
    //注意replicas 是int32的指针类型
    deploy.spec.replicas = &replacs
    _, err = clientset.appsv1().deployments("h5-web").update(context.todo(), deploy, metav1.updateoptions{})
    //查看修改后deploy的副本数
    fmt.println("修改后deploy的副本数是:", *deploy.spec.replicas)
}

2.6 client-go删除资源

删除pod，比如我们将下列的pod删除

//删除资源 delete()
//删除pod
err = clientset.corev1().pods("h5-web").delete(context.todo(), "web-864f4c6988-r456g", metav1.deleteoptions{})
if err != nil {
    panic(err.error())

可见pod已被删除

2.7 client-go创建资源

创建namespace

//创建名称空间
var namespace corev1.namespace
//创建namespace只需要传个名字就可以了
namespace.name = "test1"
// create(ctx context.context, namespace *v1.namespace, opts metav1.createoptions) (*v1.namespace, error)
//传的是指针
_, err = clientset.corev1().namespaces().create(context.todo(), &namespace, metav1.createoptions{})
if err != nil {
    panic(err.error())
}

注意，这个corev1的导包，我们要根据create()这个方法里面的导包，导过来，不要导错了，因为很多v1的包

创建deployment
注意，这个deployment的v1,

导包的时候，不要导错

传参时，要把必须得参数都传进去

可以通过这个命令来查看哪些是必须传的参数

kubectl create deployment mynginx --image="nginx" --dry-run=client -oyaml

它会导出一份yaml文件

package main
import (
    "context"
    "fmt"
    deployv1 "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"
)
func main() {
    // 1. 初始化config实例
    // masterurl就是离我们主节点的ip地址和端口号，我们在kubeconfig文件中有了，所以可以省略
    config, err := clientcmd.buildconfigfromflags("", "meta.kubeconfig")
    //要想正常应用我们的服务，必须能够实例化成功kubeconfig，要不然后面所有的功能都无法使用，所以这里直接报panic即可
    if err != nil {
        panic(err.error())
    }
    // 2. 创建客户端工具 create the clientset
    clientset, err := kubernetes.newforconfig(config)
    //这个客户端工具如果生成失败的话，后面的操作也无法完成，所以这里也报panic即可
    if err != nil {
        panic(err.error())
    }
    //3. 操作集群
    //创建deployment
    var deploy deployv1.deployment
    //给deployment传参，要把必须传的参数都传进去，不然创建会报错
    deploy.name = "mydeploy"
    deploy.namespace = "test1"
    //副本数
    replicas := int32(1)
    deploy.spec.replicas = &replicas
    //mathlabels
    labels := make(map[string]string)
    labels["app"] = "nginx"
    //selector 是个指针类型，需要先初始化
    //selector *metav1.labelselector `json:"selector" protobuf:"bytes,2,opt,name=selector"`
    deploy.spec.selector = &metav1.labelselector{}
    deploy.spec.selector.matchlabels = labels
    //deployment label   metadata会将里面的资源发布出去，metadata可以省略掉
    deploy.labels = labels
    // 创建template 这个template模版就是pod的模板
    // template v1.podtemplatespec `json:"template" protobuf:"bytes,3,opt,name=template"`
    // 此时的labels要和selector的labels一样，否则deployment就无法管理到pod
    deploy.spec.template.objectmeta.labels = labels
    //创建容器,容器是个切片，可以创建多个容器
    var containers []corev1.container
    var container corev1.container
    container.name = "nginx"
    container.image = "nginx:1.7.9"
    containers = append(containers, container)
    container.name = "redis"
    container.image = "redis:6-alpine"
    containers = append(containers, container)
    deploy.spec.template.spec.containers = containers
    _, err = clientset.appsv1().deployments("test1").create(context.todo(), &deploy, metav1.createoptions{})
}

查看创建的deploy

查看yaml文件，两个容器都创建成功

[root@master01 svc ]#kubectl get deploy -n test1 -oyaml
apiversion: v1
items:
- apiversion: apps/v1
  kind: deployment
  metadata:
    annotations:
      deployment.kubernetes.io/revision: "1"
    creationtimestamp: "2024-11-05t09:58:43z"
    generation: 1
    labels:
      app: nginx
    name: mydeploy
    namespace: test1
    resourceversion: "1079640"
    uid: 8df3654a-71c6-45d5-888d-6329ed81dad7
  spec:
    progressdeadlineseconds: 600
    replicas: 1
    revisionhistorylimit: 10
    selector:
      matchlabels:
        app: nginx
    strategy:
      rollingupdate:
        maxsurge: 25%
        maxunavailable: 25%
      type: rollingupdate
    template:
      metadata:
        creationtimestamp: null
        labels:
          app: nginx
      spec:
        containers:
        - image: nginx:1.7.9
          imagepullpolicy: ifnotpresent
          name: nginx
          resources: {}
          terminationmessagepath: /dev/termination-log
          terminationmessagepolicy: file
        - image: redis:6-alpine
          imagepullpolicy: ifnotpresent
          name: redis
          resources: {}
          terminationmessagepath: /dev/termination-log
          terminationmessagepolicy: file
        dnspolicy: clusterfirst
        restartpolicy: always
        schedulername: default-scheduler
        securitycontext: {}
        terminationgraceperiodseconds: 30
  status:
    conditions:
    - lasttransitiontime: "2024-11-05t09:58:43z"
      lastupdatetime: "2024-11-05t09:58:43z"
      message: deployment does not have minimum availability.
      reason: minimumreplicasunavailable
      status: "false"
      type: available
    - lasttransitiontime: "2024-11-05t09:58:43z"
      lastupdatetime: "2024-11-05t09:58:43z"
      message: replicaset "mydeploy-68dcc7d46d" is progressing.
      reason: replicasetupdated
      status: "true"
      type: progressing
    observedgeneration: 1
    replicas: 1
    unavailablereplicas: 1
    updatedreplicas: 1
kind: list
metadata:
  resourceversion: ""

2.8 client-go使用json串创建资源

上面使用手动填值的方式创建，还是比较麻烦的，稍微有不注意的地方还容易犯错，因此，在前后端分离的项目中，在web页面，一般我们不悔通过手动填值进行创建资源。
一般我们会根据json串来创建资源
首先我们通过先通过kubectl命令导出json串

–dry-run 选项只能为 “none”、“server”、"client"三者中的一个，默认是none；当不加该参数，或者为none的时候，该操作后资源会生效，请求会被发送到kube-apiserver并做实际更改；
当该参数为client的时候，只打印该对象并不会发送请求且并不会实际创建该对象；
当该参数为server的时候，会发送请求到服务端，但是并不会实际创建该对象。
比如我们拿到一个创建deploy的json串

kubectl create deployment myredis --image="redis" --dry-run=client -ojson

我们将json串拿出来

{
    "kind": "deployment",
    "apiversion": "apps/v1",
    "metadata": {
        "name": "myredis",
        "creationtimestamp": null,
        "labels": {
            "app": "myredis"
        }
    },
    "spec": {
        "replicas": 1,
        "selector": {
            "matchlabels": {
                "app": "myredis"
            }
        },
        "template": {
            "metadata": {
                "creationtimestamp": null,
                "labels": {
                    "app": "myredis"
                }
            },
            "spec": {
                "containers": [
                    {
                        "name": "redis",
                        "image": "redis",
                        "resources": {}
                    }
                ]
            }
        },
        "strategy": {}
    },
    "status": {}
}

使用json创建deploy完整代码：

package main
import (
    "context"
    "encoding/json"
    "fmt"
    deployv1 "k8s.io/api/apps/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
)
func main() {
    // 1. 初始化config实例
    // masterurl就是离我们主节点的ip地址和端口号，我们在kubeconfig文件中有了，所以可以省略
    config, err := clientcmd.buildconfigfromflags("", "meta.kubeconfig")
    //要想正常应用我们的服务，必须能够实例化成功kubeconfig，要不然后面所有的功能都无法使用，所以这里直接报panic即可
    if err != nil {
        panic(err.error())
    }
    // 2. 创建客户端工具 create the clientset
    clientset, err := kubernetes.newforconfig(config)
    //这个客户端工具如果生成失败的话，后面的操作也无法完成，所以这里也报panic即可
    if err != nil {
        panic(err.error())
    }
    //3. 操作集群
    //通过json串创建k8s资源，注意多行字符串用反引号包裹
    deployjson := `{
    "kind": "deployment",
    "apiversion": "apps/v1",
    "metadata": {
        "name": "myredis",
        "creationtimestamp": null,
        "labels": {
            "app": "myredis"
        }
    },
    "spec": {
        "replicas": 1,
        "selector": {
            "matchlabels": {
                "app": "myredis"
            }
        },
        "template": {
            "metadata": {
                "creationtimestamp": null,
                "labels": {
                    "app": "myredis"
                }
            },
            "spec": {
                "containers": [
                    {
                        "name": "redis",
                        "image": "redis",
                        "resources": {}
                    }
                ]
            }
        },
        "strategy": {}
    },
    "status": {}
}`
    //我们需要将json串转换成deployv1类型的资源
    var redisdeploy deployv1.deployment
    //将json转换成struct
    // func unmarshal(data []byte, v any) error
    err = json.unmarshal([]byte(deployjson), &redisdeploy)
    if err != nil {
        panic(err.error())
    }
    fmt.println("将json转换成的struct:", redisdeploy)
    //创建deploy
    _, err = clientset.appsv1().deployments("default").create(context.todo(), &redisdeploy, metav1.createoptions{})
    if err != nil {
        panic(err.error())
    }
}

在k8s集群查看下，创建成功