go不定参数在k8s中的应用

已于 2023-02-06 21:36:51 修改
阅读量241 收藏
点赞数
分类专栏： kubernetes 文章标签： kubernetes golang go
于 2022-11-15 22:43:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NUCEMLS/article/details/127875832
版权

本文是一篇面向go+k8s开发的文章，以k8s event对象为例提供一种比较优雅的、获取事件列表函数的封装方法，仅供大家参考。

k8s的event对象是一种常见的对象，在集群出现问题的时候经常会查看相关事件来定位问题。首先看看event对象的定义：

// k8s.io/api/core/v1/types.go

import (
    "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/apimachinery/pkg/types"
)

// ObjectReference contains enough information to let you inspect or modify the referred object.
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
type ObjectReference struct {
    // Kind of the referent.
    // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
    // +optional
    Kind string `json:"kind,omitempty" protobuf:"bytes,1,opt,name=kind"`
    // Namespace of the referent.
    // More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/
    // +optional
    Namespace string `json:"namespace,omitempty" protobuf:"bytes,2,opt,name=namespace"`
    // Name of the referent.
    // More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
    // +optional
    Name string `json:"name,omitempty" protobuf:"bytes,3,opt,name=name"`
    // UID of the referent.
    // More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids
    // +optional
    UID types.UID `json:"uid,omitempty" protobuf:"bytes,4,opt,name=uid,casttype=k8s.io/apimachinery/pkg/types.UID"`
    // API version of the referent.
    // +optional
    APIVersion string `json:"apiVersion,omitempty" protobuf:"bytes,5,opt,name=apiVersion"`
    // Specific resourceVersion to which this reference is made, if any.
    // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency
    // +optional
    ResourceVersion string `json:"resourceVersion,omitempty" protobuf:"bytes,6,opt,name=resourceVersion"`

    // If referring to a piece of an object instead of an entire object, this string
    // should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2].
    // For example, if the object reference is to a container within a pod, this would take on a value like:
    // "spec.containers{name}" (where "name" refers to the name of the container that triggered
    // the event) or if no container name is specified "spec.containers[2]" (container with
    // index 2 in this pod). This syntax is chosen only to have some well-defined way of
    // referencing a part of an object.
    // TODO: this design is not final and this field is subject to change in the future.
    // +optional
    FieldPath string `json:"fieldPath,omitempty" protobuf:"bytes,7,opt,name=fieldPath"`
}


// Event is a report of an event somewhere in the cluster.
type Event struct {
    metav1.TypeMeta `json:",inline"`
    // Standard object's metadata.
    // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
    metav1.ObjectMeta `json:"metadata" protobuf:"bytes,1,opt,name=metadata"`

    // The object that this event is about.
    InvolvedObject ObjectReference `json:"involvedObject" protobuf:"bytes,2,opt,name=involvedObject"`

    // This should be a short, machine understandable string that gives the reason
    // for the transition into the object's current status.
    // TODO: provide exact specification for format.
    // +optional
    Reason string `json:"reason,omitempty" protobuf:"bytes,3,opt,name=reason"`

    // A human-readable description of the status of this operation.
    // TODO: decide on maximum length.
    // +optional
    Message string `json:"message,omitempty" protobuf:"bytes,4,opt,name=message"`

    // The component reporting this event. Should be a short machine understandable string.
    // +optional
    Source EventSource `json:"source,omitempty" protobuf:"bytes,5,opt,name=source"`

    // The time at which the event was first recorded. (Time of server receipt is in TypeMeta.)
    // +optional
    FirstTimestamp metav1.Time `json:"firstTimestamp,omitempty" protobuf:"bytes,6,opt,name=firstTimestamp"`

    // The time at which the most recent occurrence of this event was recorded.
    // +optional
    LastTimestamp metav1.Time `json:"lastTimestamp,omitempty" protobuf:"bytes,7,opt,name=lastTimestamp"`

    // The number of times this event has occurred.
    // +optional
    Count int32 `json:"count,omitempty" protobuf:"varint,8,opt,name=count"`

    // Type of this event (Normal, Warning), new types could be added in the future
    // +optional
    Type string `json:"type,omitempty" protobuf:"bytes,9,opt,name=type"`

    // Time when this Event was first observed.
    // +optional
    EventTime metav1.MicroTime `json:"eventTime,omitempty" protobuf:"bytes,10,opt,name=eventTime"`

    // Data about the Event series this event represents or nil if it's a singleton Event.
    // +optional
    Series *EventSeries `json:"series,omitempty" protobuf:"bytes,11,opt,name=series"`

    // What action was taken/failed regarding to the Regarding object.
    // +optional
    Action string `json:"action,omitempty" protobuf:"bytes,12,opt,name=action"`

    // Optional secondary object for more complex actions.
    // +optional
    Related *ObjectReference `json:"related,omitempty" protobuf:"bytes,13,opt,name=related"`

    // Name of the controller that emitted this Event, e.g. `kubernetes.io/kubelet`.
    // +optional
    ReportingController string `json:"reportingComponent" protobuf:"bytes,14,opt,name=reportingComponent"`

    // ID of the controller instance, e.g. `kubelet-xyzf`.
    // +optional
    ReportingInstance string `json:"reportingInstance" protobuf:"bytes,15,opt,name=reportingInstance"`
}

基于client-go获取k8s event列表数据时，可能会有如下代码：

package main

import (
    corev1 "k8s.io/api/core/v1"
    "k8s.io/apimachinery/pkg/labels"
    listerCorev1 "k8s.io/client-go/listers/core/v1"
)

var eventLister listerCorev1.EventLister

func ListEvents(namespace string) ([]*corev1.Event, error) {
    return eventLister.Events(namespace).List(labels.Everything())
}

几天后，我们发现这个函数有了新的需求：其它模块需根据对象过滤（例如筛选pod对象的事件）、产品页面需要做事件类型(event.Type)精确匹配，以及根据事件来源类型(event.InvolvedObject.Kind)模糊匹配，而且后续还有可能增加其它筛选条件。

我们的目标是把该函数放到公共库里，这也就意味着要尽可能减少该函数的变动，包括函数名、入参、返回值，否则引用该函数的代码都得一起改动。

level1 定参

我们先直接把过滤条件作为定参进行函数封装：

import (
    "strings"

    corev1 "k8s.io/api/core/v1"
    "k8s.io/apimachinery/pkg/labels"
    listerCorev1 "k8s.io/client-go/listers/core/v1"
)

var eventLister listerCorev1.EventLister

func ListEvents(namespace string, ref *corev1.ObjectReference, tp, kind string) ([]*corev1.Event, error) {
    events, err := eventLister.Events(namespace).List(labels.Everything())
    if err != nil {
        return nil, err
    }

    ret := make([]*corev1.Event, 0, len(events))
    for _, event := range events {
        if ref != nil {
            // 过滤ref
            if ref.Namespace != "" && ref.Namespace != event.InvolvedObject.Namespace {
                continue
            }
            if ref.Name != "" && ref.Name != event.InvolvedObject.Name {
                continue
            }
            if ref.Kind != "" && ref.Kind != event.InvolvedObject.Kind {
                continue
            }
            if ref.UID != "" && ref.UID != event.InvolvedObject.UID {
                continue
            }
        }
        
        // 过滤type
        if tp != "" && tp != event.Type {
            continue
        }

        // 过滤kind
        if kind != "" && !strings.Contains(event.InvolvedObject.Kind, kind) {
            continue
        }

        ret = append(ret, event)
    }

    return ret, nil
}

但是这样写有两个明显的问题：

  1. 定参封装函数需要所有场景都传这三个参数，这并不是调用者所期望的，调用者只希望需要哪个参数传哪个参数即可；
  2. 后续如果想新增其它过滤条件，需要修改函数，会导致所有引用方都得同步修改。

level2 结构体传参

为了解决函数参数个数变动问题，我们把过滤字段封装在结构体中，这样即使后续在结构体中新增了过滤字段，对存量调用不会有影响：

import (
    "strings"

    corev1 "k8s.io/api/core/v1"
    "k8s.io/apimachinery/pkg/labels"
    listerCorev1 "k8s.io/client-go/listers/core/v1"
)

var eventLister listerCorev1.EventLister

type OptListEvents struct {
    Ref *corev1.ObjectReference
    Type string
    Kind string
}

func ListEvents(namespace string, opt OptListEvents) ([]*corev1.Event, error) {
    events, err := eventLister.Events(namespace).List(labels.Everything())
    if err != nil {
        return nil, err
    }

    ret := make([]*corev1.Event, 0, len(events))
    for _, event := range events {
        // 过滤ref
        if opt.Ref != nil {
            if opt.Ref.Namespace != "" && opt.Ref.Namespace != event.InvolvedObject.Namespace {
                continue
            }
            if opt.Ref.Name != "" && opt.Ref.Name != event.InvolvedObject.Name {
                continue
            }
            if opt.Ref.Kind != "" && opt.Ref.Kind != event.InvolvedObject.Kind {
                continue
            }
            if opt.Ref.UID != "" && opt.Ref.UID != event.InvolvedObject.UID {
                continue
            }
        }
        

        // 过滤type
        if opt.Type != "" && opt.Type != event.Type {
            continue
        }

        // 过滤kind
        if opt.Kind != "" && !strings.Contains(event.InvolvedObject.Kind, opt.Kind) {
            continue
        }

        ret = append(ret, event)
    }

    return ret, nil
}

结构体传参的方式虽然减少了函数参数变动对调用方的影响，但现在新加过滤条件时需要修改该结构体，如果该函数作为公共库函数，显然还是有缺陷的。

level3 不定参数

为了解决上述问题，我们可以基于go语言的不定参数语法来封装该函数，函数形式如下：

import (
    corev1 "k8s.io/api/core/v1"
)

func ListEventsWithOpts(namespace string, opts ...OptListEvents) ([]*corev1.Event, error) {
    // todo
}

不定参数的封装，关键在OptListEvents的定义。作为过滤条件，很明显就是对event的字段做某种规则匹配，匹配结果只需要true或false即可，因此可以把OptListEvents这么定义：

import (
    corev1 "k8s.io/api/core/v1"
)

type OptListEvents func(event *corev1.Event) bool

再把前面提到的三种过滤条件补上：

import (
    "strings"
    
    corev1 "k8s.io/api/core/v1"
)

type OptListEvents func(event *corev1.Event) bool

func OptListEventsWithRef(ref *corev1.ObjectReference) OptListEvents {
    return func(event *corev1.Event) bool {
        if ref != nil {
            if ref.Namespace != "" && ref.Namespace != event.InvolvedObject.Namespace {
                return false
            }
            if ref.Name != "" && ref.Name != event.InvolvedObject.Name {
                return false
            }
            if ref.Kind != "" && ref.Kind != event.InvolvedObject.Kind {
                return false
            }
            if ref.UID != "" && ref.UID != event.InvolvedObject.UID {
                return false
            }
        }
        return true
    }
}

func OptListEventsWithType(tp string) OptListEvents {
    return func(event *corev1.Event) bool {
        if tp != "" {
            return tp == event.Type
        }
        return true
    }
}

func OptListEventsWithKind(kind string) OptListEvents {
    return func(event *corev1.Event) bool {
        if kind != "" {
            return strings.Contains(event.InvolvedObject.Kind, kind)
        }
        return true
    }
}

于是整体函数封装如下：

import (
    "strings"

    corev1 "k8s.io/api/core/v1"
    "k8s.io/apimachinery/pkg/labels"
    listerCorev1 "k8s.io/client-go/listers/core/v1"
)

var eventLister listerCorev1.EventLister

type OptListEvents func(event *corev1.Event) bool

func OptListEventsWithRef(ref *corev1.ObjectReference) OptListEvents {
    return func(event *corev1.Event) bool {
        if ref != nil {
            if ref.Namespace != "" && ref.Namespace != event.InvolvedObject.Namespace {
                return false
            }
            if ref.Name != "" && ref.Name != event.InvolvedObject.Name {
                return false
            }
            if ref.Kind != "" && ref.Kind != event.InvolvedObject.Kind {
                return false
            }
            if ref.UID != "" && ref.UID != event.InvolvedObject.UID {
                return false
            }
        }
        return true
    }
}

func OptListEventsWithType(tp string) OptListEvents {
    return func(event *corev1.Event) bool {
        if tp != "" {
            return tp == event.Type
        }
        return true
    }
}

func OptListEventsWithKind(kind string) OptListEvents {
    return func(event *corev1.Event) bool {
        if kind != "" {
            return strings.Contains(event.InvolvedObject.Kind, kind)
        }
        return true
    }
}

func eventOptsPass(event *corev1.Event, opts ...OptListEvents) bool {
    for _, opt := range opts {
        if !opt(event) {
            return false
        }
    }
    return true
}

func ListEventsWithOpts(namespace string, opts ...OptListEvents) ([]*corev1.Event, error) {
    events, err := eventLister.Events(namespace).List(labels.Everything())
    if err != nil {
        return nil, err
    }

    ret := make([]*corev1.Event, 0, len(events))
    for _, event := range events {
        if eventOptsPass(event, opts...) {
            ret = append(ret, event)
        }
    }

    return ret, nil
}

调用方获取deployment事件：

import (
    corev1 "k8s.io/api/core/v1"
    "k8s.io/client-go/kubernetes/scheme"
    appsv1 "k8s.io/client-go/listers/apps/v1"
    "k8s.io/client-go/tools/reference"
)

var deployLister appsv1.DeploymentLister

func ListDeploymentEvents(namespace, name string) ([]*corev1.Event, error) {
    deploy, err := deployLister.Deployments(namespace).Get(name)
    if err != nil {
        return nil, err
    }
    
    ref, err := reference.GetReference(scheme.Scheme, deploy)
    if err != nil {
        return nil, err
    }
    
    return ListEventsWithOpts(namespace, OptListEventsWithRef(ref))
}

调用方根据type和kind来过滤event：

import (
    corev1 "k8s.io/api/core/v1"
)

func ListClusterEvents() ([]*corev1.Event, error) {
    var (
        tp = "Warning"
        kind = "Pod"
    )
    
    opts := []OptListEvents{
        OptListEventsWithType(tp),
        OptListEventsWithKind(kind),
    }
    return ListEventsWithOpts(corev1.NamespaceAll, opts...)
}

假设该函数已经放到公共库后又来了个新需求：需要根据事件内容(event.Message)做模糊筛选，此时调用方处理起来也很简单，只需要自己再定义一个筛选函数即可，对公共库函数没有任何影响：

import (
    "strings"

    corev1 "k8s.io/api/core/v1"
)

func OptListEventsWithMessage(message string) OptListEvents {
    return func(event *corev1.Event) bool {
        if message != "" {
            return strings.Contains(event.Message, message)
        }
        return true
    }
}

func ListClusterEvents() ([]*corev1.Event, error) {
    var (
        tp   = "Warning"
        kind = "Pod"
    )

    opts := []OptListEvents{
        OptListEventsWithType(tp),
        OptListEventsWithKind(kind),
        OptListEventsWithMessage("test"),
    }
    return ListEventsWithOpts(corev1.NamespaceAll, opts...)
}
nuczzz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在K8s上部署Go服务
create
04-09 1939
1.先添加一个最简单的golang服务 写一个main.go文件提供了一个 ping 接口： package main import ( "github.com/gin-gonic/gin" "net/http" ) func main() { router := gin.Default() router.GET("/ping", func(c *gin.Context) { c.String(http.StatusOK, "PONG") }) router.Run(":8080"
在k8s中部署prometheus的镜像
03-23
在Kubernetes（k8s）集群中部署Prometheus是一个常见的监控解决方案，Prometheus是一款强大的开源监控和警报系统，能够实时收集和分析时间序列数据。本文将详细介绍如何在k8s环境中部署Prometheus的镜像。 一、...
Go语言实现对k8s中资源的增删改查
mygugu的博客
04-21 1776
本文介绍利用go语言实现对k8s中pod/service/deployment资源的增删改查操作。（个人实际操作的记录，有错误欢迎指正呀~） K8s中有哪些资源？ 资源对象：deployment、service、ingress、replicaSet、pod、namespace、node等 核心资源： pod service deployment client-go源码 准备工作： 已安装kubernetes集群和本地IDE环境配置完成。 根据自己的kubernetes版本，下载对应源码：c
2024年Go最全K8S Pod详解(1)，Golang自学
2401_84910880的博客
05-15 954
节点亲和性 nodeAffinity 和 之前nodeSelector 基本一样的，根据节点上标签约束来决定Pod调度到哪些节点上。关于节点选择器，其实就是有两个环境，然后环境之间所用的资源配置不同。以通过以下命令，给我们的节点新增标签，然后节点选择器就会进行调度了。，发现创建pod后，pod运行节点只有node2。删除污点，之后扩容发现可以调度到节点node1了。正常情况下，node1，node2是都有的。对node1添加污点，类型为一定不会调度。就是某个节点可能被调度，也可能不被调度。
从Go程序第一行代码，到在 K8s 上运行，要经历多少步？
flynetcn的专栏
07-24 271
这篇文章就带你从写第一行代码开始，一步步教你把程序放到 K8s 跑起来。这次咱们先用 Go 做个例子，后面再写一篇怎么把 Spring Boot 应用放到 K8s 上运行。
使用client-go 进行k8s相关操作-clientset（一)
热门推荐
yevvzi的博客
10-09 1万+
package main import ( "flag" "fmt" "k8s.io/client-go/1.4/kubernetes" "k8s.io/client-go/1.4/pkg/api" "k8s.io/client-go/1.4/pkg/api/unversioned" "k8s.io/client-go/1.4/pkg/api/v1" "k8s.io/cli
【GO】 K8s 管理系统项目1[API部分--Pod]
Q先生
12-15 2435
【GO】 K8s 管理系统项目[API部分--Pod]
在k8s中部署mlflow模型服务.zip
11-03
在k8s中部署mlflow模型服务.zip在k8s中部署mlflow模型服务.zip在k8s中部署mlflow模型服务.zip在k8s中部署mlflow模型服务.zip在k8s中部署mlflow模型服务.zip在k8s中部署mlflow模型服务.zip在k8s中部署mlflow模型服务....
Online Boutique在k8s中部署演示视频
12-29
Online Boutique在k8s中部署演示视频
在K8s中部署openLooKeng集群
02-26
在K8s中部署openLooKeng集群,包括使用Dockerfile制作openLooKeng 镜像等
k8s课件k8s课件k8s课件k8s课件
02-15
本节将对k8s的基本概念、监控与日志、应用程序生命周期管理、调度、存储、集群安全等方面进行详细的解释，旨在帮助读者深入了解k8s的各个方面。 k8s基础概念 k8s是一种容器集群管理系统，由Google在2014年开源。k8...
Go微服务架构实战-中篇 1. k8s架构介绍
stackfuture的博客
01-03 1588
Go微服务架构实战本系列文章主要是针对云原生领域微服务架构的实战，包括网关，k8s，etcd以及grpc等相关技术的应用，同时也会把服务发现与注册，熔断，降级，限流以及分布式锁等加入到系列当中作为补充，课程的最后也会安排分布式链路追踪框架的学习，监控平台的搭建以及灰度发布等技术服务，所以总体来讲，课程范围涉及技术领域较广，知识面比较宽，大家下来各取所需尽量做到熟悉和应用，之后有时间了在研究下源码，乐哉！上篇已经完成，大家可以看下，我这里贴出来了，中篇从这周开始陆续为大家产出，因为太耗费精力，所以还望大家多多
Go语言开发k8s-04-Service操作
运维玄德公
10-26 671
1. 结构体 1.1 ServiceList 1.2 Service 1.3 TypeMeta 1.4 ObjectMeta 1.5 ServiceSpec 1.6 ServiceStatus 1.7 对照yml文件示例 2. Get List 3. Create 4. Get Service 5. Update Service 6. Delete Service
2024年最新【算法学习】剑指 Offer 64(2)，2024年最新vue总结来了
2401_84910839的博客
05-12 295
--### c// 2的14次正好超过10000// 等差数列求和公式n * (n + 1) / 2public:// 2的14次正好超过10000// 等差数列求和公式n * (n + 1) / 2# 2的14次正好超过10000# 等差数列求和公式n * (n + 1) / 2ans = 0a = nb = n + 1// 2的14次正好超过10000// 等差数列求和公式n * (n + 1) / 2ans += a。
【k8s多集群管理平台开发实践】四、client-go实现deployment列表、创建deployment、读取yaml配置、重启deployment
weixin_56364253的博客
04-28 1217
通过client-go、beego实现deployment列表、创建deployment、读取yaml配置、重启deployment这四个功能，再结合layui、layuimini模板实现也没展，功能只要是由控制器、模型、路由、前端代码几部分组成，现将各个模块的功能进行分布讲解。
基于 Golang 的 K8s 二次开发细节汇总
weixin_36532747的博客
04-16 6575
前情提要 针对 K8s 进行二次开发设计时，通常会采用 kubebuilder & client-go 的方式进行远程调用，通过 golang 进行开发时，往往需要基于项目实现部分业务逻辑通过汇总，这个方式是基于 golang 进行展开的，本博客将从以下层面展开针对 client-go 的一些注意问题，分别是 golang 的依赖管理；K8s 的认证管理；client-go 的接入实现； golang 的依赖管理 这是一个环境变量，用于指定工作空间的位置。 在GOPATH/src目录中，我们为每个
Go语言开发k8s(client-go)-03-Deployment挂载configmap、pvc、host path
运维玄德公
05-05 493
1. 定义需要的结构体 2. 创建deployment的函数 3. 定义一个解释器
Go最全k8s学习 — （实践）第四章 资源调度(1)，真的醉了
最新发布
2401_84910943的博客
05-16 905
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新如果你需要这些资料，可以戳这里获取[root@k8s-master deployments]# kubectl set image deployment/nginx-deploy nginx=nginx:1.91 deployment.apps/ngi
go基于k8s二次开发(二）
阿白，
06-14 824
接下来用代码创建资源，先将前面的main函数改个名比如list()，作为一个模块，都是在同一个目录下，同一个main包，下面创建main函数，实现这个创建资源的操作，因为go run需要有main函数存在 (模块化编程)先放源码 create方法需要的参 看源码可以知道client-go创建deployment主要是写这些信息 可以看到的ObjectMeta结构体中可以定义哪些内容都是这样，详细的内容记不住就看源码或者帮助文档...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值