关于kubernetes:Kubernetes-Operator-开发入门

Kubernetes operator 是一种封装、部署、治理 kubernetes 利用的办法。它是 Kubernetes 的扩大软件，利用 自定义资源 治理利用及组件。
operator 所有的操作都是调用 Kubernetes Apiserver 的接口，所以实质上它也是 Apiserver 的客户端软件。

本文是对于 Kubernetes operator 开发入门的教程，旨在率领有趣味理解 Operator 开发的老手一窥 Operator 开发的根本流程。

首先你须要有一个可用的 kubernetes 测试集群，如果你对 kubernetes 相干概念，集群建设还没有充沛的理解，我倡议你先理解这方面的常识
本教程应用 Go 语言，须要你对 Go 语言的语法有简略的理解，Go 语言也是 kubernetes 的开发语言。如果你应用其余语言也是没有问题的，进入到底层都是 HTTP 申请。官网的或社区的 SDK 也提供了多种语言可供选择，当你理解了其中原理，再应用其余语言进行开发该当是能得心应手
咱们将应用官网提供的 k8s.io/client-go 库来做测试, 它根本封装了对 Kurbernetes 的大部分操作。

示例代码目录如下：

├── Dockerfile
├── go.mod
├── go.sum
├── k8s           // 客户端封装
│   └── client.go
├── LICENSE
├── main.go
├── Makefile
├── utils       // 助手组件
│   ├── errs
│   │   └── errs.go
│   └── logs
│       └── slog.go
└── yaml
    ├── Deployment.yaml    //operator 部署文件
    └── ServiceAccount.yaml // 权限绑定文件，下文把权限配置，绑定定义离开了，这里放在一起也是能够的

作为演示，本教程咱们次要关注以下几个方面的操作：

列出所有 Node/namespace
列出指定命名空间的 Deployment/Services
创立一个 Deployment/Service
删除 Deployment/Service

Operator 的开发跟你平时开发的程序并无二致，它最重要的关注点是权限问题。Kubernetes 有十分严格粗疏的权限设计，具体到每个资源每个操作。
所以咱们的 Operator 软件并无严格要求必须运行在 Kubernetes 集群的容器里，只有权限配置切当，你能够间接运行 go build 进去的二进制包，甚至你能够间接在你的开发环境里 go run 都是能够的。通常咱们为了开发调试不便，都会间接采纳这种形式运行。

如果你对 Kubernetes 的权限治理并不相熟，我倡议你把你的代码放在你的测试集群的 Master 节点里运行，Master 节点领有集群的最高权限，省去了你配置权限的麻烦，把次要精力集中在业务逻辑下面。

首先咱们须要在代码中实例化一个 k8s.io/client-go/kubernetes.Clientset 类型的对象变量，它就是咱们整个 Operator 利用操作的客户端对象。

它能够由

func NewForConfig(c *rest.Config) (*Clientset, error)
func NewForConfigOrDie(c *rest.Config) *Clientset

两个函数实例化。
两个函数的区别：一个是实例化失败返回谬误，另一个间接抛出异样。通常倡议应用前者，由程序处理谬误，而不是间接抛出异样。

两个办法都须要一个 rest.Config 对象作为参数，rest.Config最重要的配置我的项目就是权限配置。

SDK 给咱们提供了 func BuildConfigFromFlags(masterUrl, kubeconfigPath string) (*restclient.Config, error) 办法来实例化 rest.Config 对象。

masterUrl参数就是主节点的 Server URL
kubeconfigPath参数就是权限配置文件门路。

Master 节点的权限配置文件通常是文件：/etc/kubernetes/admin.conf。

kubernetes 在部署 master 节点后通过会倡议你把 /etc/kubernetes/admin.conf 文件拷贝到$HOME/.kube/config，所以你看到这两个中央的文件内容是一样的。

咱们在传参的时候通常倡议应用 $HOME/.kube/config 文件，免得因为文件权限问题出现异常，减少问题的复杂性。

BuildConfigFromFlags办法两个参数其实都是能够传空值的，如果咱们的 Operator 程序在 Kubernetes 集群容器里运行，传空值（通过也是这么干的）进来它会应用容器里的默认权限配置。然而在非 kubernetes 集群容器里，它没有这个默认配置的，所以在非 kubernetes 集群容器咱们须要显式把权限配置文件的门路传入。

说了一堆，咱们间接上代码吧：


import "k8s.io/client-go/kubernetes"

// 调用之前请确认文件存在，如果不存在应用 /etc/kubernetes/admin.conf
cfg, err := clientcmd.BuildConfigFromFlags("","/root/.kube/config") 
if err != nil {log.Fatalln(err)
}
k8sClient, err := kubernetes.NewForConfig(cfg)
if err != nil {log.Fatalln(err)
}

k8sClient就是咱们频繁应用的客户端对象。

文章开端附带了本次教程的代码 repo，最终的代码通过调整与润色，保障最终的代码是可用的。

上面咱们来开始展现“真正的技术”。

//ListNodes 获取所有节点
func ListNodes(g *gin.Context) {nodes, err := k8sClient.CoreV1().Nodes().List(context.Background(), metav1.ListOptions{})
    if err != nil {g.Error(err)
        return
    }
    g.JSON(0, nodes)
}

//ListNamespace 获取所有命令空间
func ListNamespace(g *gin.Context) {ns, err := k8sClient.CoreV1().Namespaces().List(context.Background(),metav1.ListOptions{})
    if err != nil {g.Error(err)
        return
    }
    g.JSON(0, ns)
}

为简略，咱们把接口返回的数据不作工作解决间接打印进去。

返回内容太多，我就不把内容贴出来了。从返回内容咱们能够看到节点信息蕴含了

零碎信息
节点状态
节点事件
资源使用量
节点标签，注解，创立工夫等
节点本地的镜像，容器组

不一一例举了，有趣味的读者在本人的环境运行起来看看输入后果。

上面是 namespace 打印进去的后果，截取了一个命名空间的数据。

{
    "metadata": {"resourceVersion": "190326"},
    "items": [
        {
            "metadata": {
                "name": "default",
                "uid": "acf4b9e4-b1ae-4b7a-bbdc-b65f088e14ec",
                "resourceVersion": "208",
                "creationTimestamp": "2021-09-24T11:17:29Z",
                "labels": {"kubernetes.io/metadata.name": "default"},
                "managedFields": [
                    {
                        "manager": "kube-apiserver",
                        "operation": "Update",
                        "apiVersion": "v1",
                        "time": "2021-09-24T11:17:29Z",
                        "fieldsType": "FieldsV1",
                        "fieldsV1": {
                            "f:metadata": {
                                "f:labels": {".": {},
                                    "f:kubernetes.io/metadata.name": {}}
                            }
                        }
                    }
                ]
            },
            "spec": {
                "finalizers": ["kubernetes"]
            },
            "status": {"phase": "Active"}
        },
        ... ...
    ]
}

// 列出指定命名空间的 deployment
func ListDeployment(g *gin.Context) {ns := g.Query("ns")
    
    dps, err := k8sClient.AppsV1().Deployments(ns).List(context.Background(), metav1.ListOptions{})
    if err != nil {g.Error(err)
        return
    }
    g.JSON(200, dps)
}
// 列出指定命名空间的 Services
func ListService(g *gin.Context) {ns := g.Query("ns")

    svc, err := k8sClient.CoreV1().Services(ns).List(context.Background(), metav1.ListOptions{})
    if err != nil {g.Error(err)
        return
    }
    g.JSON(200, svc)
}

通过参数指定命名空间。
咱们来看看返回后果：

# deployment
{
    ... ...
    "items": [
        {
            "metadata": {
                "name": "nginx",
                "namespace": "testing",
                "labels": {
                    "k8s.kuboard.cn/layer": "web",
                    "k8s.kuboard.cn/name": "nginx"
                },
                ... ...
            },
            "spec": {
                "replicas": 2,
                "selector": {
                    "matchLabels": {
                        "k8s.kuboard.cn/layer": "web",
                        "k8s.kuboard.cn/name": "nginx"
                    }
                },
                "template": {
                    "metadata": {
                        "labels": {
                            "k8s.kuboard.cn/layer": "web",
                            "k8s.kuboard.cn/name": "nginx"
                        }
                    },
                    "spec": {
                        "containers": [
                            {
                                "name": "nginx",
                                "image": "nginx:alpine",
                                ... ...
                            }
                        ],
                    }
                },
                "strategy": {
                    "type": "RollingUpdate",
                    "rollingUpdate": {
                        "maxUnavailable": "25%",
                        "maxSurge": "25%"
                    }
                },
            },
            "status": ...
        }
        ... ...
    ]
}

# Services
{
    "items": [
        {
            "metadata": {
                "name": "nginx",
                "namespace": "testing",
                "labels": {
                    "k8s.kuboard.cn/layer": "web",
                    "k8s.kuboard.cn/name": "nginx"
                },
                "managedFields": [...]
            },
            "spec": {
                "ports": [
                    {
                        "name": "nkcers",
                        "protocol": "TCP",
                        "port": 8080,
                        "targetPort": 80
                    }
                ],
                "selector": {
                    "k8s.kuboard.cn/layer": "web",
                    "k8s.kuboard.cn/name": "nginx"
                },
                "clusterIP": "10.96.55.66",
                "clusterIPs": ["10.96.55.66"],
                "type": "ClusterIP",
                "sessionAffinity": "None",
                "ipFamilies": ["IPv4"],
                "ipFamilyPolicy": "SingleStack"
            },
            "status": ...
        }
        ... ...
    ]
}

从后果来看 testing 命名空间下有一个名为 nginx 的Deployment，应用的是 nginx:alpine 镜像。一个名为 nginx 的Service以 ClusterIP 模式映射 8080 端口到同名 Deployment 的 80 端口。

func CreateDeployment(g *gin.Context) {
    var replicas int32 = 2
    var AutomountServiceAccountTokenYes bool = true

    deployment := &apiAppv1.Deployment{
        TypeMeta:   metav1.TypeMeta{
            Kind:       "Deployment",
            APIVersion: "apps/v1",
        },
        ObjectMeta: metav1.ObjectMeta{
            Name:  "k8s-test-stub",
            Namespace: "testing",
            Labels: map[string]string{"app": "k8s-test-app",},
            Annotations: map[string]string{"creator":"k8s-operator-test",},
        },
        Spec: apiAppv1.DeploymentSpec{
            Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"app": "k8s-test-app",},
            },
            Replicas:  &replicas,
            Template: v1.PodTemplateSpec{
                ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"app": "k8s-test-app",},
                },
                Spec:v1.PodSpec{Containers: []apiCorev1.Container{
                        {
                            Name:  "nginx",
                            Image: "nginx:alpine",
                        },
                    },
                    RestartPolicy: "Always",
                    DNSPolicy: "ClusterFirst",
                    NodeSelector: nil,
                    ServiceAccountName: "",
                    AutomountServiceAccountToken:  &AutomountServiceAccountTokenYes,
                },
            },
            Strategy: apiAppv1.DeploymentStrategy{
                Type: "RollingUpdate",
                RollingUpdate: &apiAppv1.RollingUpdateDeployment{
                    MaxUnavailable: &intstr.IntOrString{
                        Type:   intstr.String,
                        IntVal: 0,
                        StrVal: "25%",
                    },
                    MaxSurge: &intstr.IntOrString{
                        Type: intstr.String,
                        IntVal: 0,
                        StrVal: "25%",
                    },
                },
            },
        },
    }

    dp, err := k8sClient.AppsV1().Deployments("testing").Create(context.Background(), deployment, metav1.CreateOptions{})
    if err != nil {g.AbortWithStatusJSON(500, err)
        return
    }
    g.JSON(200, dp)
}

下面的代码就是在 testing 命名空间创立一个名为 k8s-test-stub 的Deployment。容器应用的是 nginx:alpine 镜像，replicas指定为 2. 配置精简了很多非必要的配置项。
执行胜利后咱们能够看到两个 pod 曾经启动了：

root@main ~# kubectl get pods -n testing --selector=app=k8s-test-app
NAME                             READY   STATUS    RESTARTS   AGE
k8s-test-stub-7bcdb4f5ff-bmcgf   1/1     Running   0          16m
k8s-test-stub-7bcdb4f5ff-cmng8   1/1     Running   0          16m

接下来咱们给这个 Deployment 创立Service，让它能够对外提供服务，代码如下：

func CreateService(g *gin.Context) {
    svc := &apiCorev1.Service{
        TypeMeta:   metav1.TypeMeta{
            Kind:       "Service",
            APIVersion: "v1",
        },
        ObjectMeta: metav1.ObjectMeta{
            Name: "k8s-test-stub",
            Namespace: "testing",
            Labels: map[string]string{"app": "k8s-test-app",},
            Annotations: map[string]string{"creator":"k8s-test-operator",},
        },
        Spec:apiCorev1.ServiceSpec{Ports: []apiCorev1.ServicePort{
                {
                    Name:        "http",
                    Protocol:    "TCP", // 留神这里必须为大写
                    Port:        80,
                    TargetPort:  intstr.IntOrString{
                        Type:   intstr.Int,
                        IntVal: 80,
                        StrVal: "",
                    },
                    NodePort:    0,
                },
            },
            Selector: map[string]string{"app": "k8s-test-app",},
            Type: "NodePort",
        },
    }

    svs, err := k8sClient.CoreV1().Services("testing").Create(context.Background(), svc, metav1.CreateOptions{})
    if err != nil {g.AbortWithStatusJSON(500, err)
        return
    }
    g.JSON(200, svs)
}

下面代码为 k8s-test-stub Deployment 创立一个同名的 Service。以NodePort 形式对外提供服务

root@main ~# kubectl get svc -n testing --selector=app=k8s-test-app
NAME            TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
k8s-test-stub   NodePort    10.96.138.143   <none>        80:30667/TCP   113s

func DeleteDeploymentAndService(g *gin.Context) {
    // 删除 Deployment
    err := k8sClient.AppsV1().Deployments("testing").Delete(context.Background(), "k8s-test-stub", metav1.DeleteOptions{})
    if err != nil {g.AbortWithStatusJSON(500, err)
        return
    }
    // 删除 Service
    err = k8sClient.CoreV1().Services("testing").Delete(context.Background(), "k8s-test-stub", metav1.DeleteOptions{})
    if err != nil {g.AbortWithStatusJSON(500, err)
        return
    }
    g.JSON(200, nil)
}

上述代码删除了 testing 命名空间中名为 k8s-test-stub 的Deployment和对应的Service。

root@main ~# kubectl get deployment,svc -n testing --selector=app=k8s-test-app
No resources found in testing namespace.

后面的代码示例演示了创立命名空间，创立和删除 Deployment、Service 的基本操作，作为抛砖引玉，更多的操作留待读者去摸索分享。

后面的示例都是间接运行在 master 主节点的 Host 环境里，不便咱们援用主节点的权限配置。
咱们的 operator 最终是要运行在 k8s 集群里的。如果不进行必要的权限设置，咱们大概率会失去相似以下的谬误：

{
    "ErrStatus": {"metadata": {},
        "status": "Failure",
        "message": "nodes is forbidden: User \"system:serviceaccount:testing:default\"cannot list resource \"nodes\"in API group \"\"at the cluster scope",
        "reason": "Forbidden",
        "details": {"kind": "nodes"},
        "code": 403
    }
}

下面的返回后果就是 nodes 操作被禁止了，因为 operator 没有足够的运行权限。

那如何赋予 operator 足够的权限来满足咱们的需要？

前文提到过 k8s 有着严格详尽的权限设计，为了平安思考，集群里一般的容器并没有赋予过多的权限。每个容器默认领有的权限无奈满足大部分 operator 的性能需要。

咱们先来看看 Operator 在容器里是如何获取权限配置的。

咱们先从 SDK 的代码开始。我在 SDK 中能够找到以下代码：

func BuildConfigFromFlags(masterUrl, kubeconfigPath string) (*restclient.Config, error) {
    if kubeconfigPath == ""&& masterUrl =="" {klog.Warning("Neither --kubeconfig nor --master was specified.  Using the inClusterConfig.  This might not work.")
        kubeconfig, err := restclient.InClusterConfig()
        if err == nil {return kubeconfig, nil}
        klog.Warning("error creating inClusterConfig, falling back to default config:", err)
    }
    return NewNonInteractiveDeferredLoadingClientConfig(&ClientConfigLoadingRules{ExplicitPath: kubeconfigPath},
        &ConfigOverrides{ClusterInfo: clientcmdapi.Cluster{Server: masterUrl}}).ClientConfig()}

这段代码是构建客户端配置的办法。咱们后面在调用这部分代码的时候输出了 kubeconfigPath 参数，把 master 节点的权限文件传进来了，所以咱们的 operator 领有了超级管理员的所有权限。尽管不便，也带了极大的平安危险，Operator 领有所有权限能够干很多好事。

从代码能够看到 BuildConfigFromFlags 函数是容许传入参数空值，在传入的参数为空的时候会调用 restclient.InClusterConfig() 办法，咱们进入到这个办法：

func InClusterConfig() (*Config, error) {
    const (
        tokenFile  = "/var/run/secrets/kubernetes.io/serviceaccount/token"
        rootCAFile = "/var/run/secrets/kubernetes.io/serviceaccount/ca.crt"
    )
    host, port := os.Getenv("KUBERNETES_SERVICE_HOST"), os.Getenv("KUBERNETES_SERVICE_PORT")
    if len(host) == 0 || len(port) == 0 {return nil, ErrNotInCluster}

    token, err := ioutil.ReadFile(tokenFile)
    if err != nil {return nil, err}

    tlsClientConfig := TLSClientConfig{}

    if _, err := certutil.NewPool(rootCAFile); err != nil {klog.Errorf("Expected to load root CA config from %s, but got err: %v", rootCAFile, err)
    } else {tlsClientConfig.CAFile = rootCAFile}

    return &Config{Host:            "https://" + net.JoinHostPort(host, port),
        TLSClientConfig: tlsClientConfig,
        BearerToken:     string(token),
        BearerTokenFile: tokenFile,
    }, nil
}

咱们看到代码援用了容器里以下两个文件：

/var/run/secrets/kubernetes.io/serviceaccount/token
/var/run/secrets/kubernetes.io/serviceaccount/ca.crt

这两个文件就是 k8s 集群赋予容器的默认权限配置。它其实对应的就是以后命名空间里一个名为 default 的ServiceAccount（每个命名空间在创立的时候都会附带创立一个 default 的ServiceAccount并生成一个名称相似 default-token-xxxx 密文和名为 kube-root-ca.crt 字典）。上述两个文件映射的就是这两个配置。

更多对于 ServiceAccount 的常识，请参加官网的文档！

默认的 default ServiceAccount 满足不了 Operator 的须要，咱们须要创立一个新的 ServiceAccount 同时赋予它足够的权限。

首先须要定义ClusterRole

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: k8s-operator、annotations:
    app: k8s-operator-test
rules:
  - apiGroups:
      - apps
    resources:
      - daemonsets
      - deployments
      - replicasets
      - statefulsets
    verbs:
      - create
      - delete
      - get
      - list
      - update
      - watch
      - patch
  - apiGroups:
      - ''
    resources:
      - nodes
      - namespaces
      - pods
      - services
      - serviceaccounts
    verbs:
      - create
      - delete
      - get
      - list
      - patch
      - update
      - watch

创立新的ServiceAccount, 名为k8s-test-operator：

apiVersion: v1
kind: ServiceAccount
metadata:
  name: k8s-test-operator
  namespace: testing
  annotations:
    app: k8s-operator-test
secrets:
  - name: k8s-test-operator-token-2hfbn

绑定 ClusterRole 到ServiceAccount:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: k8s-test-operator-cluster
  annotations:
    app: k8s-operator-test
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: k8s-operator
subjects:
  - kind: ServiceAccount
    name: k8s-test-operator
    namespace: testing

执行 kubbectl apply -f *.yaml 让权限绑定失效，而后咱们在 Deployment 的配置文件中的以下地位指定新的角色名

deployment.Spec.Template.Spec.ServiceAccountName: "k8s-test-operator"

咱们能够间接执行：kubectl edit deployment operator-test -n testing找到 Spec.Template.Spec 增加serviceAccountName: k8s-test-operator，使权限绑定失效。

咱们再顺次执行方才的命令

列出所有 Node/namespace
列出指定命名空间的 Deployment/Services
创立一个 Deployment/Service
删除 Deployment/Service
能够看到都能失常的执行

kubernetes operator 开发跟平时开发软件没什么区别，最终都是调用 ApiServer 的 http 接口。惟一须要关注的是权限，operator 只有领有足够的权限就能实现你能设想的所有性能！

demo repo: https://gitee.com/longmon/k8s…

关于kubernetes:Kubernetes-Operator-开发入门

一、介绍

二、筹备工作

三、开始

0x01、初始化客户端对象

0x02、列出所有 nodes/namespace

0x03、列出指定命名空间的 Deployment/Services

0x04 创立一个 Deployment/Service

0x05 删除 Deployment/Service

四、让你的 Operator 运行在 Kubernetes 集群里

总结