关于云计算:kubebuilder实战之五operator编码

欢送拜访我的 GitHub

https://github.com/zq2599/blog_demos

内容：所有原创文章分类汇总及配套源码，波及 Java、Docker、Kubernetes、DevOPS 等；

系列文章链接

1. kubebuilder 实战之一：筹备工作
2. kubebuilder 实战之二：首次体验 kubebuilder
3. kubebuilder 实战之三：基础知识速览
4. kubebuilder 实战之四：operator 需要阐明和设计
5. kubebuilder 实战之五：operator 编码
6. kubebuilder 实战之六：构建部署运行
7. kubebuilder 实战之七：webhook
8. kubebuilder 实战之八：知识点小记

本篇概览

• 本篇是《kubebuilder 实战》系列的第五篇，后面的所有致力 (环境筹备、常识储备、需要剖析、数据结构和业务逻辑设计)，都是为了将之前的设计用编码实现；
• 既然曾经充分准备，现在无需太多语言，咱们开始入手吧！

源码下载

• 本篇实战中的残缺源码可在 GitHub 下载到，地址和链接信息如下表所示 (https://github.com/zq2599/blog_demos)：

• 这个 git 我的项目中有多个文件夹，kubebuilder 相干的利用在 <font color=”blue”>kubebuilder</font> 文件夹下，如下图红框所示：

• kubebuilder 文件夹下有多个子文件夹，本篇对应的源码在 <font color=”blue”>elasticweb</font> 目录下，如下图红框所示：

新建我的项目 elasticweb

• 新建名为 <font color=”blue”>elasticweb</font> 的文件夹，在外面执行以下命令即可创立名为 <font color=”blue”>elasticweb</font> 的我的项目，domain 为 <font color=”blue”>com.bolingcavalry</font>：

go mod init elasticweb
kubebuilder init --domain com.bolingcavalry

• 而后是 CRD，执行以下命令即可创立相干资源：

kubebuilder create api \
--group elasticweb \
--version v1 \
--kind ElasticWeb

• 而后用 IDE 关上整个工程，我这里是 goland：

CRD 编码

• 关上文件 <font color=”blue”>api/v1/elasticweb_types.go</font>，做以下几步改变：
• 批改数据结构 ElasticWebSpec，减少前文设计的四个字段；
• 批改数据结构 ElasticWebStatus，减少前文设计的一个字段；
• 减少 String 办法，这样打印日志时不便咱们查看，留神 RealQPS 字段是指针，因而可能为空，须要判空；
• 残缺的 <font color=”blue”>elasticweb_types.go</font> 如下所示：

package v1

import (
    "fmt"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "strconv"
)

// 冀望状态
type ElasticWebSpec struct {
    // 业务服务对应的镜像，包含名称:tag
    Image string `json:"image"`
    // service 占用的宿主机端口，内部申请通过此端口拜访 pod 的服务
    Port *int32 `json:"port"`

    // 单个 pod 的 QPS 下限
    SinglePodQPS *int32 `json:"singlePodQPS"`
    // 以后整个业务的总 QPS
    TotalQPS *int32 `json:"totalQPS"`
}

// 理论状态，该数据结构中的值都是业务代码计算出来的
type ElasticWebStatus struct {
    // 以后 kubernetes 中理论反对的总 QPS
    RealQPS *int32 `json:"realQPS"`
}

// +kubebuilder:object:root=true

// ElasticWeb is the Schema for the elasticwebs API
type ElasticWeb struct {
    metav1.TypeMeta   `json:",inline"`
    metav1.ObjectMeta `json:"metadata,omitempty"`

    Spec   ElasticWebSpec   `json:"spec,omitempty"`
    Status ElasticWebStatus `json:"status,omitempty"`
}

func (in *ElasticWeb) String() string {
    var realQPS string

    if nil == in.Status.RealQPS {realQPS = "nil"} else {realQPS = strconv.Itoa(int(*(in.Status.RealQPS)))
    }

    return fmt.Sprintf("Image [%s], Port [%d], SinglePodQPS [%d], TotalQPS [%d], RealQPS [%s]",
        in.Spec.Image,
        *(in.Spec.Port),
        *(in.Spec.SinglePodQPS),
        *(in.Spec.TotalQPS),
        realQPS)
}

// +kubebuilder:object:root=true

// ElasticWebList contains a list of ElasticWeb
type ElasticWebList struct {
    metav1.TypeMeta `json:",inline"`
    metav1.ListMeta `json:"metadata,omitempty"`
    Items           []ElasticWeb `json:"items"`}

func init() {SchemeBuilder.Register(&ElasticWeb{}, &ElasticWebList{})
}

• 在 elasticweb 目录下执行 <font color=”blue”>make install</font> 即可部署 CRD 到 kubernetes：

zhaoqin@zhaoqindeMBP-2 elasticweb % make install
/Users/zhaoqin/go/bin/controller-gen "crd:trivialVersions=true" rbac:roleName=manager-role webhook paths="./..." output:crd:artifacts:config=config/crd/bases
kustomize build config/crd | kubectl apply -f -
Warning: apiextensions.k8s.io/v1beta1 CustomResourceDefinition is deprecated in v1.16+, unavailable in v1.22+; use apiextensions.k8s.io/v1 CustomResourceDefinition
customresourcedefinition.apiextensions.k8s.io/elasticwebs.elasticweb.com.bolingcavalry created

• 部署胜利后，用 <font color=”blue”>api-versions</font> 命令能够查到该 GV：

回顾业务逻辑

• 外围数据结构设计编码结束，接下来该编写业务逻辑代码了，大家还记得前文设计的业务流程吧，简略回顾一下，如下图：
  
• 关上文件 <font color=”blue”>elasticweb_controller.go</font>，接下来咱们逐步增加内容；

增加资源拜访权限

• 咱们的 elasticweb 会对 service、deployment 这两种资源做查问、新增、批改等操作，因而须要这些资源的操作权限，减少下图红框中的两行正文，这样代码生成工具就会在 RBAC 配置中减少对应的权限：

常量定义

• 先把常量筹备好，可见每个 pod 应用的 CPU 和内存都是在此固定的，您也能够改成在 Spec 中定义，这样就能够从内部传入了，另外这里为每个 pod 只调配了 0.1 个 CPU，次要是因为我穷买不起好的 CPU，您能够酌情调整该值：

const (
    // deployment 中的 APP 标签名
    APP_NAME = "elastic-app"
    // tomcat 容器的端口号
    CONTAINER_PORT = 8080
    // 单个 POD 的 CPU 资源申请
    CPU_REQUEST = "100m"
    // 单个 POD 的 CPU 资源下限
    CPU_LIMIT = "100m"
    // 单个 POD 的内存资源申请
    MEM_REQUEST = "512Mi"
    // 单个 POD 的内存资源下限
    MEM_LIMIT = "512Mi"
)

办法 getExpectReplicas

• 有个很重要的逻辑：依据单个 pod 的 QPS 和总 QPS，计算须要多少个 pod，咱们将这个逻辑封装到一个办法中以便应用：

/ 依据单个 QPS 和总 QPS 计算 pod 数量
func getExpectReplicas(elasticWeb *elasticwebv1.ElasticWeb) int32 {
    // 单个 pod 的 QPS
    singlePodQPS := *(elasticWeb.Spec.SinglePodQPS)

    // 冀望的总 QPS
    totalQPS := *(elasticWeb.Spec.TotalQPS)

    // Replicas 就是要创立的正本数
    replicas := totalQPS / singlePodQPS

    if totalQPS%singlePodQPS > 0 {replicas++}

    return replicas
}

办法 createServiceIfNotExists

• 将创立 service 的操作封装到一个办法中，是的骨干代码的逻辑更清晰，可读性更强；
• 创立 service 的时候，有几处要留神：
• 先查看 service 是否存在，不存在才创立；
• 将 service 和 CRD 实例 elasticWeb 建设关联 (controllerutil.SetControllerReference 办法)，这样当 elasticWeb 被删除的时候，service 会被主动删除而无需咱们干涉；
• 创立 service 的时候用到了 <font color=”blue”>client-go</font> 工具，举荐您浏览《client-go 实战系列》, 工具越纯熟，编码越尽兴；
• 创立 service 的残缺办法如下：

// 新建 service
func createServiceIfNotExists(ctx context.Context, r *ElasticWebReconciler, elasticWeb *elasticwebv1.ElasticWeb, req ctrl.Request) error {log := r.Log.WithValues("func", "createService")

    service := &corev1.Service{}

    err := r.Get(ctx, req.NamespacedName, service)

    // 如果查问后果没有谬误，证实 service 失常，就不做任何操作
    if err == nil {log.Info("service exists")
        return nil
    }

    // 如果谬误不是 NotFound，就返回谬误
    if !errors.IsNotFound(err) {log.Error(err, "query service error")
        return err
    }

    // 实例化一个数据结构
    service = &corev1.Service{
        ObjectMeta: metav1.ObjectMeta{
            Namespace: elasticWeb.Namespace,
            Name:      elasticWeb.Name,
        },
        Spec: corev1.ServiceSpec{Ports: []corev1.ServicePort{{
                Name:     "http",
                Port:     8080,
                NodePort: *elasticWeb.Spec.Port,
            },
            },
            Selector: map[string]string{"app": APP_NAME,},
            Type: corev1.ServiceTypeNodePort,
        },
    }

    // 这一步十分要害！// 建设关联后，删除 elasticweb 资源时就会将 deployment 也删除掉
    log.Info("set reference")
    if err := controllerutil.SetControllerReference(elasticWeb, service, r.Scheme); err != nil {log.Error(err, "SetControllerReference error")
        return err
    }

    // 创立 service
    log.Info("start create service")
    if err := r.Create(ctx, service); err != nil {log.Error(err, "create service error")
        return err
    }

    log.Info("create service success")

    return nil
}

办法 createDeployment

• 将创立 deployment 的操作封装在一个办法中，同样是为了将骨干逻辑放弃简洁；
• 创立 deployment 的办法也有几处要留神：
• 调用 getExpectReplicas 办法失去要创立的 pod 的数量，该数量是创立 deployment 时的一个重要参数；
• 每个 pod 所需的 CPU 和内存资源也是 deployment 的参数；
• 将 deployment 和 elasticweb 建设关联，这样删除 elasticweb 的时候 deplyment 就会被主动删除了；
• 同样是应用 client-go 客户端工具创立 deployment 资源；

// 新建 deployment
func createDeployment(ctx context.Context, r *ElasticWebReconciler, elasticWeb *elasticwebv1.ElasticWeb) error {log := r.Log.WithValues("func", "createDeployment")

    // 计算冀望的 pod 数量
    expectReplicas := getExpectReplicas(elasticWeb)

    log.Info(fmt.Sprintf("expectReplicas [%d]", expectReplicas))

    // 实例化一个数据结构
    deployment := &appsv1.Deployment{
        ObjectMeta: metav1.ObjectMeta{
            Namespace: elasticWeb.Namespace,
            Name:      elasticWeb.Name,
        },
        Spec: appsv1.DeploymentSpec{
            // 正本数是计算出来的
            Replicas: pointer.Int32Ptr(expectReplicas),
            Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"app": APP_NAME,},
            },

            Template: corev1.PodTemplateSpec{
                ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"app": APP_NAME,},
                },
                Spec: corev1.PodSpec{Containers: []corev1.Container{
                        {
                            Name: APP_NAME,
                            // 用指定的镜像
                            Image:           elasticWeb.Spec.Image,
                            ImagePullPolicy: "IfNotPresent",
                            Ports: []corev1.ContainerPort{
                                {
                                    Name:          "http",
                                    Protocol:      corev1.ProtocolSCTP,
                                    ContainerPort: CONTAINER_PORT,
                                },
                            },
                            Resources: corev1.ResourceRequirements{
                                Requests: corev1.ResourceList{"cpu":    resource.MustParse(CPU_REQUEST),
                                    "memory": resource.MustParse(MEM_REQUEST),
                                },
                                Limits: corev1.ResourceList{"cpu":    resource.MustParse(CPU_LIMIT),
                                    "memory": resource.MustParse(MEM_LIMIT),
                                },
                            },
                        },
                    },
                },
            },
        },
    }

    // 这一步十分要害！// 建设关联后，删除 elasticweb 资源时就会将 deployment 也删除掉
    log.Info("set reference")
    if err := controllerutil.SetControllerReference(elasticWeb, deployment, r.Scheme); err != nil {log.Error(err, "SetControllerReference error")
        return err
    }

    // 创立 deployment
    log.Info("start create deployment")
    if err := r.Create(ctx, deployment); err != nil {log.Error(err, "create deployment error")
        return err
    }

    log.Info("create deployment success")

    return nil
}

办法 updateStatus

• 不论是创立 deployment 资源对象，还是对已有的 deployment 的 pod 数量做调整，这些操作实现后都要去批改 Status，既理论的状态，这样内部能力随时随地晓得以后 elasticweb 反对多大的 QPS，因而须要将批改 Status 的操作封装到一个办法中，给多个场景应用，Status 的计算逻辑很简略：pod 数量乘以每个 pod 的 QPS 就是总 QPS 了，代码如下：

// 实现了 pod 的解决后，更新最新状态
func updateStatus(ctx context.Context, r *ElasticWebReconciler, elasticWeb *elasticwebv1.ElasticWeb) error {log := r.Log.WithValues("func", "updateStatus")

    // 单个 pod 的 QPS
    singlePodQPS := *(elasticWeb.Spec.SinglePodQPS)

    // pod 总数
    replicas := getExpectReplicas(elasticWeb)

    // 当 pod 创立结束后，以后零碎理论的 QPS：单个 pod 的 QPS * pod 总数
    // 如果该字段还没有初始化，就先做初始化
    if nil == elasticWeb.Status.RealQPS {elasticWeb.Status.RealQPS = new(int32)
    }

    *(elasticWeb.Status.RealQPS) = singlePodQPS * replicas

    log.Info(fmt.Sprintf("singlePodQPS [%d], replicas [%d], realQPS[%d]", singlePodQPS, replicas, *(elasticWeb.Status.RealQPS)))

    if err := r.Update(ctx, elasticWeb); err != nil {log.Error(err, "update instance error")
        return err
    }

    return nil
}

骨干代码

• 后面细枝末节都处理完毕，能够开始主流程了，有了后面的流程图的赋值，主流程的代码很容就写进去了，如下所示，曾经增加了足够的正文，就不再赘述了：

func (r *ElasticWebReconciler) Reconcile(req ctrl.Request) (ctrl.Result, error) {
    // 会用到 context
    ctx := context.Background()
    log := r.Log.WithValues("elasticweb", req.NamespacedName)

    // your logic here

    log.Info("1. start reconcile logic")

    // 实例化数据结构
    instance := &elasticwebv1.ElasticWeb{}

    // 通过客户端工具查问，查问条件是
    err := r.Get(ctx, req.NamespacedName, instance)

    if err != nil {

        // 如果没有实例，就返回空后果，这样内部就不再立刻调用 Reconcile 办法了
        if errors.IsNotFound(err) {log.Info("2.1. instance not found, maybe removed")
            return reconcile.Result{}, nil}

        log.Error(err, "2.2 error")
        // 返回错误信息给内部
        return ctrl.Result{}, err}

    log.Info("3. instance :" + instance.String())

    // 查找 deployment
    deployment := &appsv1.Deployment{}

    // 用客户端工具查问
    err = r.Get(ctx, req.NamespacedName, deployment)

    // 查找时产生异样，以及查出来没有后果的解决逻辑
    if err != nil {
        // 如果没有实例就要创立了
        if errors.IsNotFound(err) {log.Info("4. deployment not exists")

            // 如果对 QPS 没有需要，此时又没有 deployment，就啥事都不做了
            if *(instance.Spec.TotalQPS) < 1 {log.Info("5.1 not need deployment")
                // 返回
                return ctrl.Result{}, nil}

            // 先要创立 service
            if err = createServiceIfNotExists(ctx, r, instance, req); err != nil {log.Error(err, "5.2 error")
                // 返回错误信息给内部
                return ctrl.Result{}, err}

            // 立刻创立 deployment
            if err = createDeployment(ctx, r, instance); err != nil {log.Error(err, "5.3 error")
                // 返回错误信息给内部
                return ctrl.Result{}, err}

            // 如果创立胜利就更新状态
            if err = updateStatus(ctx, r, instance); err != nil {log.Error(err, "5.4. error")
                // 返回错误信息给内部
                return ctrl.Result{}, err}

            // 创立胜利就能够返回了
            return ctrl.Result{}, nil} else {log.Error(err, "7. error")
            // 返回错误信息给内部
            return ctrl.Result{}, err}
    }

    // 如果查到了 deployment，并且没有返回谬误，就走上面的逻辑

    // 依据单 QPS 和总 QPS 计算冀望的正本数
    expectReplicas := getExpectReplicas(instance)

    // 以后 deployment 的冀望正本数
    realReplicas := *deployment.Spec.Replicas

    log.Info(fmt.Sprintf("9. expectReplicas [%d], realReplicas [%d]", expectReplicas, realReplicas))

    // 如果相等，就间接返回了
    if expectReplicas == realReplicas {log.Info("10. return now")
        return ctrl.Result{}, nil}

    // 如果不等，就要调整
    *(deployment.Spec.Replicas) = expectReplicas

    log.Info("11. update deployment's Replicas")
    // 通过客户端更新 deployment
    if err = r.Update(ctx, deployment); err != nil {log.Error(err, "12. update deployment replicas error")
        // 返回错误信息给内部
        return ctrl.Result{}, err}

    log.Info("13. update status")

    // 如果更新 deployment 的 Replicas 胜利，就更新状态
    if err = updateStatus(ctx, r, instance); err != nil {log.Error(err, "14. update status error")
        // 返回错误信息给内部
        return ctrl.Result{}, err}

    return ctrl.Result{}, nil}

• 至此，整个 elasticweb operator 编码就实现了，限于篇幅，咱们把部署、运行、镜像制作等操作放在下一篇文章吧；

你不孤独，欣宸原创一路相伴

1. Java 系列
2. Spring 系列
3. Docker 系列
4. kubernetes 系列
5. 数据库 + 中间件系列
6. DevOps 系列

欢送关注公众号：程序员欣宸

微信搜寻「程序员欣宸」，我是欣宸，期待与您一起畅游 Java 世界 …
https://github.com/zq2599/blog_demos