4. client-go 编程式交互

Kubernetes 系统使用 client-go 作为 Go 语言的官方编程式交互客户端库，提供对 Kubernetes API Server 服务的交互访问。Kubernetes 的源码中已经集成了 client-go 的源码，无须单独下载。client-go 源码路径为 vendor/k8s.io/client-go。

开发者经常使用 client-go 基于 Kubernetes 做二次开发，所以 client-go 是开发者应熟练掌握的必会技能。


1. client-go 源码结构

client-go 的代码库已经集成到 Kubernetes 源码中了，无须考虑版本兼容性问题，源码结构示例如下：

在这里插入图片描述

Client-Go 共提供了 4 种与 Kubernetes APIServer 交互的客户端。分别是 RESTClient、DiscoveryClient、ClientSet、DynamicClient。

  • RESTClient：最基础的客户端，主要是对 HTTP 请求进行了封装，支持 Json 和 Protobuf 格式的数据。DiscoveryClient、ClientSet、DynamicClient 客户端都是基于 RESTClient 实现的。
  • DiscoveryClient：发现客户端，负责发现 APIServer 支持的资源组、资源版本和资源信息（即 Group、Versions、Resources）。
  • ClientSet：在 RESTClient 的基础上封装了对 Resource 和 Version 的管理方法。负责操作 Kubernetes 内置的资源对象，例如：Pod、Service 等。每一个 Resource 可以理解为一个客户端，而 ClientSet 则是多个客户端的集合，每一个 Resource 和 Version 都以函数的方式暴露给开发者。ClientSet 只能够处理 Kubernetes 内置资源，它是通过 client-gen 代码生成器自动生成的。
  • DynamicClient：动态客户端，可以对任意的 Kubernetes 资源对象进行通用操作，包括 CRD 自定义资源。

在这里插入图片描述

以上 4 种客户端：RESTClient、DiscoveryClient、ClientSet、DynamicClient 都可以通过 kubeconfig 配置信息连接到指定的 Kubernetes API Server。


2. kubeconfig 配置管理

kubeconfig 用于管理访问 kube-apiserver 的配置信息，同时也支持访问多 kube-apiserver 的配置管理，可以在不同的环境下管理不同的 kube-apiserver 集群配置，不同的业务线也可以拥有不同的集群。Kubernetes 的其他组件都使用 kubeconfig 配置信息来连接 kube-apiserver 组件，例如当 kubectl 访问 kube-apiserver 时，会默认加载 kubeconfig 配置信息。

kubeconfig 中存储了集群、用户、命名空间和身份验证等信息，在默认的情况下，kubeconfig 存放在 $HOME/.kube/config 路径下。kubeconfig 配置信息如下：

$ cat $HOME/.kube/config
apiVersion: v1
kind: Config
preferences: {}clusters:
- cluster:name: dev-clusteruser:
- name: dev-usercontexts:
- contextname: dev-context

kubeconfig 配置信息通常包含 3 个部分，分别介绍如下：

  • clusters： 定义 Kubernetes 集群信息，例如 kube-apiserver 的服务地址以及集群的证书信息等。
  • user：定义 Kubernetes 集群用户身份验证的客户端凭证，例如 client-certificate、client-key、token 以及 username/password 等。
  • contexts：定义 Kubernetes 集群用户信息和命名空间等，用户将请求发送到指定的集群。

client-go 会读取 kubeconfig 配置信息并生成 config 对象，用于与 kube-apiserver 通信，代码示例如下：

package mainimport ("k8s.io/client-go/tools/clientcmd"
)func main() {config, err := clientcmd.BuildConfigFromFlag("", "/root/.kube/config")if err != nil {panic(err)}...
}

在上述代码中，clientcmd.BuildConfigFromFlag 函数会读取 kubeconfig 配置信息并实例化 rest.Config 对象。其中 kubeconfig 最核心的功能是管理多个访问 kube-apiserver 集群的配置信息，将多个配置信息合并（merge）成一份，在合并的过程中会解决多个配置文件字段冲突的问题。该过程由 Load 函数完成，可以分为两步：第 1 步，加载 kubeconfig 配置信息；第 2 步，合并多个 kubeconfig 配置信息。代码示例如下：

1.加载 kubeconfig 配置信息

代码路径：vendor\k8s.io\client-go\tools\clientcmd\loader.go

func (rules *ClientConfigLoadingRules) Load() (*clientcmdapi.Config, error) {if err := rules.Migrate(); err != nil {return nil, err}errlist := []error{}missingList := []string{}kubeConfigFiles := []string{}// Make sure a file we were explicitly told to use existsif len(rules.ExplicitPath) > 0 {if _, err := os.Stat(rules.ExplicitPath); os.IsNotExist(err) {return nil, err}kubeConfigFiles = append(kubeConfigFiles, rules.ExplicitPath)} else {kubeConfigFiles = append(kubeConfigFiles, rules.Precedence...)}kubeconfigs := []*clientcmdapi.Config{}// read and cache the config files so that we only look at them oncefor _, filename := range kubeConfigFiles {if len(filename) == 0 {// no work to docontinue}config, err := LoadFromFile(filename)if os.IsNotExist(err) {// skip missing files// Add to the missing list to produce a warningmissingList = append(missingList, filename)continue}if err != nil {errlist = append(errlist, fmt.Errorf("error loading config file \"%s\": %v", filename, err))continue}kubeconfigs = append(kubeconfigs, config)}...
}

有两种方式可以获取 kubeconfig 配置信息路径：第 1 种，文件路径（即 rules.ExplicitPath）；第 2 种，环境变量（通过 KUBECONFIG 变量，即 rules.Precedence，可以指定多个路径）。最后将配置信息汇总到 kubeConfigFiles 中。这两种方式都通过 LoadFromFile 函数读取数据并把读取到的数据反序列化到 Config 对象中。代码示例如下：

代码路径：vendor\k8s.io\client-go\tools\clientcmd\loader.go

// Load takes a byte slice and deserializes the contents into Config object.
// Encapsulates deserialization without assuming the source is a file.
func Load(data []byte) (*clientcmdapi.Config, error) {config := clientcmdapi.NewConfig()// if there's no data in a file, return the default object instead of failing (DecodeInto reject empty input)if len(data) == 0 {return config, nil}decoded, _, err := clientcmdlatest.Codec.Decode(data, &schema.GroupVersionKind{Version: clientcmdlatest.Version, Kind: "Config"}, config)if err != nil {return nil, err}return decoded.(*clientcmdapi.Config), nil
}

2.合并多个 kubeconfig 配置信息

有两份 kubeconfig 配置，集群分别为 cow-cluster 和 pig-cluster，经过合并后，最终得到一份多集群的配置信息，代码示例如下：

config := clientcmdapi.NewConfig()
mergo.Merge(config, mapConfig, mergo.WithOverride)
mergo.Merge(config, nonMapConfig, mergo.WithOverride)

mergo.Merge 函数将 src 字段填充到 dst 结构中，私有字段除外，非空的 dst 字段将被覆盖。另外，dst 和 src 必须拥有有效的相同类型结构。合并过程举例如下：

src 结构：    T{X: "two", Z: Z{A: "three", B: 4}}
dst 结构：    T{X: "one", Y: 5, Z: Z{A: "four", B: 6}}
merge 后的结构：T{X: "two", Y: 5, Z: Z{A: "three", B: 4}}

3. RESTClient 客户端

RESTClient 是所有客户端的父类，这也是为啥前面说，它是最基础的客户端的原因。

它提供了 RESTful 对应的方法的封装，如：Get()、Put()、Post()、Delete() 等。通过这些封装发方法与 Kubernetes APIServer RESTful API 进行交互。

因为它是所有客户端的父类，DiscoveryClient、ClientSet、DynamicClient 客户端都是基于 RESTClient 实现的。所以它可以操作 Kubernetes 内置的所有资源对象以及 CRD。

运行以下代码，将得到 default 下的 Pod 部分相关资源信息。

package mainimport ("context""fmt"corev1 "k8s.io/api/core/v1"metav1 "k8s.io/apimachinery/pkg/apis/meta/v1""k8s.io/client-go/kubernetes/scheme""k8s.io/client-go/rest""k8s.io/client-go/tools/clientcmd"
)func main() {// 加载配置文件，生成 config 对象config, err := clientcmd.BuildConfigFromFlags("", "../../kubeconfig")if err != nil {panic(err.Error())}// 配置 API 路径config.APIPath = "api"// 配置分组版本config.GroupVersion = &corev1.SchemeGroupVersion// 配置数据的编解码器config.NegotiatedSerializer = scheme.Codecs// 实例化 RESTClientrestClient, err := rest.RESTClientFor(config)if err != nil {panic(err.Error())}// 定义返回接收值result := &corev1.PodList{}err = restClient.Get().Namespace("default"). // 查询的 NamespaceResource("pods"). // 查询的资源类型VersionedParams(&metav1.ListOptions{Limit: 100}, scheme.ParameterCodec). // 参数及序列化工具Do(context.TODO()). // 发送请求Into(result) // 写入返回值if err != nil {panic(err.Error())}// 输出返回结果for _, d := range result.Items {fmt.Printf("namespace: %v, name: %v, status: %v\n", d.Namespace, d.Name, d.Status.Phase)}
}

运行以下代码，将得到 default 下的 Pod 部分相关资源信息。首先加载 kubeconfig 配置信息，并设置 config.APIPath 请求的 HTTP 路径。然后设置 config.GroupVersion 请求的资源组/资源版本。最后设置 config.NegotiatedSerializer 数据的编解码器。

RESTClient 其实就是底层使用 net/http 库，将调用 Kubernetes APIServer 的 API 请求，进行了封装，对参数和返回结果进行了序列化及反序列化。

代码路径如下：vendor\k8s.io\client-go\rest\request.go

func (r *Request) Do(ctx context.Context) Result {var result Resulterr := r.request(ctx, func(req *http.Request, resp *http.Response) {result = r.transformResponse(resp, req)})if err != nil {return Result{err: err}}if result.err == nil || len(result.body) > 0 {metrics.ResponseSize.Observe(ctx, r.verb, r.URL().Host, float64(len(result.body)))}return result
}func (r *Request) request(ctx context.Context, fn func(*http.Request, *http.Response)) error {// Metrics for total request latencystart := time.Now()defer func() {metrics.RequestLatency.Observe(ctx, r.verb, r.finalURLTemplate(), time.Since(start))}()if r.err != nil {klog.V(4).Infof("Error in request: %v", r.err)return r.err}if err := r.requestPreflightCheck(); err != nil {return err}client := r.c.Clientif client == nil {client = http.DefaultClient}// Throttle the first try before setting up the timeout configured on the// client. We don't want a throttled client to return timeouts to callers// before it makes a single request.if err := r.tryThrottle(ctx); err != nil {return err}if r.timeout > 0 {var cancel context.CancelFuncctx, cancel = context.WithTimeout(ctx, r.timeout)defer cancel()}isErrRetryableFunc := func(req *http.Request, err error) bool {// "Connection reset by peer" or "apiserver is shutting down" are usually a transient errors.// Thus in case of "GET" operations, we simply retry it.// We are not automatically retrying "write" operations, as they are not idempotent.if req.Method != "GET" {return false}// For connection errors and apiserver shutdown errors retry.if net.IsConnectionReset(err) || net.IsProbableEOF(err) {return true}return false}// Right now we make about ten retry attempts if we get a Retry-After response.retry := r.retryFn(r.maxRetries)for {if err := retry.Before(ctx, r); err != nil {return retry.WrapPreviousError(err)}req, err := r.newHTTPRequest(ctx)if err != nil {return err}resp, err := client.Do(req)updateURLMetrics(ctx, r, resp, err)// The value -1 or a value of 0 with a non-nil Body indicates that the length is unknown.// https://pkg.go.dev/net/http#Requestif req.ContentLength >= 0 && !(req.Body != nil && req.ContentLength == 0) {metrics.RequestSize.Observe(ctx, r.verb, r.URL().Host, float64(req.ContentLength))}retry.After(ctx, r, resp, err)done := func() bool {defer readAndCloseResponseBody(resp)// if the server returns an error in err, the response will be nil.f := func(req *http.Request, resp *http.Response) {if resp == nil {return}fn(req, resp)}if retry.IsNextRetry(ctx, r, req, resp, err, isErrRetryableFunc) {return false}f(req, resp)return true}()if done {return retry.WrapPreviousError(err)}}
}

请求发送之前需要根据请求参数生成请求的 RESTful URL，由 r.URL.String 函数完成。例如，在 RESTClient Example 代码示例中，根据请求参数生成请求的 RESTful URL 为 http://127.0.0.1:8080/api/v1/namespaces/default/pods?limit=500，其中 api 参数为 v1，namespace 参数为 default，请求的资源为 pods，limit 参数表示最多检索出 500 条信息。

最后通过 Go 语言标准库 net/http 向 RESTful URL（即 kube-apiserver）发送请求，请求得到的结构存放在 http.Response 的 Body 对象中，fn 函数（即 transformResponse）将结果转换为资源对象。当函数退出时，会通过 rest.Body.Close 命令进行关闭，防止内存溢出。


4. ClientSet 客户端

上面介绍了 RESTClient，它虽然可以操作 Kubernetes 的所有资源对象，但是使用起来确实比较复杂，需要配置的参数过于繁琐，如需要指定 Resource 和 Version 等信息，因此，为了更优雅的更方便的与 Kubernetes APIServer 进行交互，则需要进一步的封装。

前面有过介绍，ClientSet 是基于 RESTClient 的封装，同时 ClientSet 是使用预生成的 API 对象与 APIServer 进行交互的，这样做更方便进行二次开发。

ClientSet 在 RESTClient 的基础上封装了对 Resource 和 Version 的管理方法。负责操作 Kubernetes 内置的资源对象，例如：Pod、Service 等。每一个 Resource 可以理解为一个客户端，而 ClientSet 则是多个客户端的集合，每一个 Resource 和 Version 都以函数的方式暴露给开发者。ClientSet 是一组资源对象客户端的集合，例如负责操作 Pods、Services 等资源的 CoreV1Client，负责操作 Deployments、DaemonSets 等资源的 AppsV1Client 等。通过这些资源对象客户端提供的操作方法，即可对 Kubernetes 内置的资源对象进行 Create、Update、Get、List、Delete 等操作。

运行以下代码，将得到 default 下的 Pod 部分相关资源信息。

package mainimport ("context""fmt"metav1 "k8s.io/apimachinery/pkg/apis/meta/v1""k8s.io/client-go/kubernetes""k8s.io/client-go/tools/clientcmd"
)/*@Author : lanyulei@Desc :
*/func main() {// 加载配置文件，生成 config 对象config, err := clientcmd.BuildConfigFromFlags("", "../../kubeconfig")if err != nil {panic(err.Error())}// 实例化 ClientSetclientset, err := kubernetes.NewForConfig(config)if err != nil {panic(err.Error())}// 查询 default 下的 pods 部门资源信息pods, err := clientset.CoreV1().                                  // 实例化资源客户端，这里标识实例化 CoreV1ClientPods("default").                           // 选择 namespace，为空则表示所有 NamespaceList(context.TODO(), metav1.ListOptions{limit:500}) // 查询 pods 列表if err != nil {panic(err.Error())}// 输出 Pods 资源信息for _, item := range pods.Items {fmt.Printf("namespace: %v, name: %v\n", item.Namespace, item.Name)}
}

运行以上代码，列出 default 命名空间下的所有 pod 资源对象的相关信息。首先加载 kubeconfig 配置信息，kubernetes.NewForConfig 通过 kubeconfig 配置信息实例化 clientset 对象，该对象用于管理所有 Resource 的客户端。

clientset.CoreV1().Pods 函数表示请求 core 核心资源组的 v1 资源版本下的 Pod 资源对象，其内部设置了 APIPath 请求的 HTTP 路径，GroupVersion 请求的资源组、资源版本，NegotiatedSerializer 数据的编解码器。

其中， Pods 函数时一个资源接口对象，用于 Pod 资源对象的管理，例如，对 Pod 资源执行 Create、Update、Delete、Get、List、Watch、Patch 等操作，这些操作实际上是对 RESTClient 进行了封装，可以设置选项（如 Limit、TimeoutSeconds 等）。List 函数通过 RESTClient 获得 Pod 列表，代码如下：

代码路径：vendor\k8s.io\client-go\kubernetes\typed\core\v1\pod.go

// List takes label and field selectors, and returns the list of Pods that match those selectors.
func (c *pods) List(ctx context.Context, opts metav1.ListOptions) (result *v1.PodList, err error) {var timeout time.Durationif opts.TimeoutSeconds != nil {timeout = time.Duration(*opts.TimeoutSeconds) * time.Second}result = &v1.PodList{}err = c.client.Get().Namespace(c.ns).Resource("pods").VersionedParams(&opts, scheme.ParameterCodec).Timeout(timeout).Do(ctx).Into(result)return
}

5. DynamicClient 客户端

DynamicClient 是一种动态客户端，通过动态指定资源组、资源版本和资源等信息，来操作任意的 Kubernetes 资源对象的一种客户端。即不仅仅是操作 Kubernetes 内置的资源对象，还可以操作 CRD。这也是与 ClientSet 最明显的一个区别。

使用 ClientSet 的时候，程序会将所用的版本与类型紧密耦合。而 DynamicClient 使用嵌套的 map[string]interface{} 结构存储 Kubernetes APIServer 的返回值，使用反射机制，在运行的时候，进行数据绑定，这种方式更加灵活，但是却无法获取强数据类型的检查和验证。

此外，在介绍 DynamicClient 之前，还需要了解另外两个重要的知识点，Object.runtime 接口和 Unstructured 结构体。

Object.runtime：Kubernetes 中的所有资源对象，都实现了这个接口，其中包含 DeepCopyObject 和 GetObjectKind 的方法，分别用于对象深拷贝和获取对象的具体资源类型。
Unstructured：包含 map[string]interface{} 类型字段，在处理无法预知结构的数据时，将数据值存入 interface{} 中，待运行时利用反射判断。该结构体提供了大量的工具方法，便于处理非结构化的数据。这也是 DynamicClient 能够处理 CRD 自定义资源的关键。ClientSet 则需要预先实现每种 Resource 和 Version 的操作，其内部的数据都是结构化数据。

DynamicClient 的处理过程将 Resource（例如 PodList）转换成 Unstructured 结构类型，Kubernetes 的所有 Resource 都可以转换为该结构类型。处理完成后，再将 Unstructured 转换成 PodList。整个过程类似于 Go 语言的 interface{} 断言转换过程。另外，Unstructured 结构类型是通过 map[string]interface{} 转换的。

运行以下代码，将得到 default 下的 Pod 部分相关资源信息。

package mainimport ("context""fmt"corev1 "k8s.io/api/core/v1"metav1 "k8s.io/apimachinery/pkg/apis/meta/v1""k8s.io/apimachinery/pkg/runtime""k8s.io/apimachinery/pkg/runtime/schema""k8s.io/client-go/dynamic""k8s.io/client-go/tools/clientcmd"
)/*@Author : lanyulei@Desc :
*/func main() {// 加载配置文件，生成 config 对象config, err := clientcmd.BuildConfigFromFlags("", "../../kubeconfig")if err != nil {panic(err.Error())}// 实例化 DynamicClientdynamicClient, err := dynamic.NewForConfig(config)if err != nil {panic(err.Error())}// 设置要请求的 GVRgvr := schema.GroupVersionResource{Group:    "",Version:  "v1",Resource: "pods",}// 发送请求，并得到返回结果unStructData, err := dynamicClient.Resource(gvr).Namespace("default").List(context.TODO(), metav1.ListOptions{})if err != nil {panic(err.Error())}// 使用反射将 unStructData 的数据转成对应的结构体类型，例如这是是转成 v1.PodList 类型podList := &corev1.PodList{}err = runtime.DefaultUnstructuredConverter.FromUnstructured(unStructData.UnstructuredContent(),podList,)if err != nil {panic(err.Error())}// 输出 Pods 资源信息for _, item := range podList.Items {fmt.Printf("namespace: %v, name: %v\n", item.Namespace, item.Name)}
}

运行以上代码，列出 default 命名空间下的所有 pod 资源对象的相关信息。首先加载 kubeconfig 配置信息，dynamic.NewForConfig 通过 kubeconfig 配置信息实例化 DynamicClient 对象，该对象用于管理所有 Resource 的客户端。

dynamicClient.Resource(gvr) 函数用于设置请求的资源组、资源版本、资源名称。Namespace 函数用于设置请求的命名空间。List 函数用于获取 Pod 列表。得到的 Pod 列表为 unstructured.UnstructuredList 指针类型，然后通过 runtime.DefaultUnstructuredConverter.FromUnstructured 函数将 unstructured.UnstructuredList 转换为 PodList 类型。


6. DiscoveryClient 客户端

DiscoveryClient 是发现客户端，它主要用于发现 Kubernetes API Server 所支持的资源组、资源版本、资源信息。Kubernetes API Server 支持很多资源组、资源版本、资源信息，开发者在开发过程中很难记住所有信息，此时可以通过 DiscoveryClient 查看所支持的资源组、资源版本、资源信息。

前面咱们介绍了 3 种客户端，都是针对与资源对象管理的。而 DiscoveryClient 则是针对于资源的。用于查看当前 Kubernetes 集群支持那些资源组、资源版本、资源信息。

DiscoveryClient 除了可以发现 Kubernetes API Server 所支持的资源组、资源版本、资源信息，还可以将这些信息存储到本地，用于本地缓存（Cache），以减轻对 Kubernetes API Server 访问的压力。在运行 Kubernetes 组件的机器上，缓存信息默认存储于 ~/.kube/cache 和 ~/.kube/http-cache 中。

运行以下代码，将得到 Kubernetes 集群的资源列表。

package mainimport ("fmt""k8s.io/apimachinery/pkg/runtime/schema""k8s.io/client-go/discovery""k8s.io/client-go/tools/clientcmd"
)/*@Author : lanyulei@Desc :
*/func main() {// 加载配置文件，生成 config 对象config, err := clientcmd.BuildConfigFromFlags("", "../../kubeconfig")if err != nil {panic(err.Error())}// 实例化 DiscoveryClientdiscoveryClient, err := discovery.NewDiscoveryClientForConfig(config)if err != nil {panic(err.Error())}_, apiResources, err := discoveryClient.ServerGroupsAndResources()if err != nil {panic(err.Error())}for _, list := range apiResources {gv, err := schema.ParseGroupVersion(list.GroupVersion)if err != nil {panic(err.Error())}for _, resource := range list.APIResources {fmt.Printf("name: %v, group: %v, version: %v\n", resource.Name, gv.Group, gv.Version)}}
}

输出结果：

➜  demo1 go run main.go
name: bindings, group: , version: v1
name: componentstatuses, group: , version: v1
name: configmaps, group: , version: v1
name: endpoints, group: , version: v1
name: events, group: , version: v1
...

1.获取 Kubernetes API Server 所支持的资源组、资源版本、资源信息

Kubernetes API Server 暴露出 /api 和 /apis 接口。DiscoveryClient 通过 RESTClient 分别请求 /api 和 /apis 接口，从而获取 Kubernetes API Server 所支持的资源组、资源版本、资源信息。其核心实现位于 ServerGroupAndResources -> ServerGroups 中，代码示例如下：

代码路径：vendor\k8s.io\client-go\discovery\discovery_client.go

// ServerGroups returns the supported groups, with information like supported versions and the
// preferred version.
func (d *DiscoveryClient) ServerGroups() (apiGroupList *metav1.APIGroupList, err error) {// Get the groupVersions exposed at /apiv := &metav1.APIVersions{}err = d.restClient.Get().AbsPath(d.LegacyPrefix).Do(context.TODO()).Into(v)apiGroup := metav1.APIGroup{}if err == nil && len(v.Versions) != 0 {apiGroup = apiVersionsToAPIGroup(v)}if err != nil && !errors.IsNotFound(err) && !errors.IsForbidden(err) {return nil, err}// Get the groupVersions exposed at /apisapiGroupList = &metav1.APIGroupList{}err = d.restClient.Get().AbsPath("/apis").Do(context.TODO()).Into(apiGroupList)if err != nil && !errors.IsNotFound(err) && !errors.IsForbidden(err) {return nil, err}// to be compatible with a v1.0 server, if it's a 403 or 404, ignore and return whatever we got from /apiif err != nil && (errors.IsNotFound(err) || errors.IsForbidden(err)) {apiGroupList = &metav1.APIGroupList{}}// prepend the group retrieved from /api to the list if not emptyif len(v.Versions) != 0 {apiGroupList.Groups = append([]metav1.APIGroup{apiGroup}, apiGroupList.Groups...)}return apiGroupList, nil
}

首先 DiscoveryClient 通过 RESTClient 分别请求 /api 接口，将请求结果放于 metav1.APIVersions 结构体中。然后再次通过 RESTClient 请求 /apis 接口，将请求结果存放于 metav1.APIGroupList 结构体中。最后，将 /api 接口中检索到的资源组信息合并到 apiGroupList 列表中并返回。

2.本地缓存的 DiscoveryClient

DiscoveryClient 可以将资源相关信息存储到本地，默认存储位置为~/.kube/cache 和 ~/.kube/http-cache 中。存储可以减轻 client-go 对 Kubernetes API Server 的访问压力。默认每 10 分钟与 Kubernetes API Server 同步一次，同步周期较长，因为资源组、资源版本、资源信息一般很少变动。

DiscoveryClient 第一次获取资源组、资源版本、资源信息时，首先会查询本地缓存，如果数据不存在（没有命中）则请求 Kubernetes API Server 接口（回源），Cache 将 Kubernetes API Server 响应的数据存储在本地一份并返回给 DiscoveryClient。当下一次 DiscoveryClient 再次获取资源信息时，会将数据直接从本地缓存返回（命中）给 DiscoveryClient。本地缓存的默认存储周期为 10 分钟。

代码路径：vendor\k8s.io\client-go\discovery\cached\disk\cached_discovery.go

// ServerResourcesForGroupVersion returns the supported resources for a group and version.
func (d *CachedDiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {filename := filepath.Join(d.cacheDirectory, groupVersion, "serverresources.json")cachedBytes, err := d.getCachedFile(filename)// don't fail on errors, we either don't have a file or won't be able to run the cached check. Either way we can fallback.if err == nil {cachedResources := &metav1.APIResourceList{}if err := runtime.DecodeInto(scheme.Codecs.UniversalDecoder(), cachedBytes, cachedResources); err == nil {klog.V(10).Infof("returning cached discovery info from %v", filename)return cachedResources, nil}}liveResources, err := d.delegate.ServerResourcesForGroupVersion(groupVersion)if err != nil {klog.V(3).Infof("skipped caching discovery info due to %v", err)return liveResources, err}if liveResources == nil || len(liveResources.APIResources) == 0 {klog.V(3).Infof("skipped caching discovery info, no resources found")return liveResources, err}if err := d.writeCachedFile(filename, liveResources); err != nil {klog.V(1).Infof("failed to write cache to %v due to %v", filename, err)}return liveResources, nil
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/265456.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

rviz显示双臂ur10

rviz显示双臂ur10

注意有线网的连接 注意这里rviz只做显示用，并没有结合moveit 步骤总结如下： launch文件：这里tf加上域名，是tool0_controller和base两个tf的前缀 在luanch文件最后就统一加载一次模型，传递两个参数 这里加上另一个机…
阅读更多...
【Go语言】Go语言中的切片

【Go语言】Go语言中的切片

Go语言中的切片 1.切片的定义 Go语言中，切片是一个新的数据类型数据类型，与数组最大的区别在于，切片的类型中只有数据元素的类型，而没有长度： var slice []string []string{"a", "b", "c…
阅读更多...
大模型（LLM）的token学习记录-I

大模型（LLM）的token学习记录-I

文章目录 基本概念什么是token?如何理解token的长度？使用openai tokenizer 观察token的相关信息open ai的模型 token的特点token如何映射到数值？token级操作：精确地操作文本token 设计的局限性 tokenizationtoken 数量对LLM 的影响训练模型参…
阅读更多...
【React源码 - 调度任务循环EventLoop】

【React源码 - 调度任务循环EventLoop】

我们知道在React中有4个核心包、2个关键循环。而React正是在这4个核心包中运行，从输入到输出渲染到web端，主要流程可简单分为一下4步：如下图，本文主要是介绍两大循环中的任务调度循环。 4个核心包： react：…
阅读更多...
day02_前后端环境搭建(前端工程搭建,登录功能说明,后端项目搭建)

day02_前后端环境搭建(前端工程搭建,登录功能说明,后端项目搭建)

文章目录 1. 软件开发介绍1.1 软件开发流程1.2 角色分工1.3 软件环境1.4 系统的分类 2. 尚品甄选项目介绍2.1 电商基本概念2.1.1 电商简介2.1.2 电商模式B2BB2CB2B2CC2BC2CO2O 2.2 业务功能介绍2.3 系统架构介绍2.4 前后端分离开发 3. 前端工程搭建3.1 Element-Admin简介3.2 El…
阅读更多...
WordPress前端如何使用跟后台一样的Dashicons图标字体？

WordPress前端如何使用跟后台一样的Dashicons图标字体？

很多站长都喜欢在站点菜单或其他地方添加一些图标字体，常用的就是添加Font Awesome 图标和阿里巴巴矢量库图标iconfont。其实我们使用的 WordPress 本身就有一套管理员使用的官方图标字体 Dashicons，登录我们站点后台就能看到这些图标字体。那么有没有可…
阅读更多...
dcat admin 自定义页面

dcat admin 自定义页面

自定义用户详情页 整体分为两部分：用户信息、tab框 用户信息采用自定义页面加载，controller代码如下： protected function detail($id) {return Show::make($id, GameUser::with(finance), function (Show $show) {// 这段就是加载自定义页面…
阅读更多...
RunnerGo UI自动化测试脚本如何配置

RunnerGo UI自动化测试脚本如何配置

RunnerGo提供从API管理到API性能再到可视化的API自动化、UI自动化测试功能模块，覆盖了整个产品测试周期。 RunnerGo UI自动化基于Selenium浏览器自动化方案构建，内嵌高度可复用的测试脚本，测试团队无需复杂的代码编写即可开展低代码的自动化…
阅读更多...
求两个向量之间的夹角

求两个向量之间的夹角

求两个向量之间的夹角 介绍Unity的API求向量夹角Vector3.AngleVector3.SignedAngle 自定义获取方法0-360度的夹角 总结 介绍 求两个向量之间的夹角方法有很多，比如说Unity中的Vector3.Angle，Vector3.SignedAngle等方法，具体在什么情况下使用…
阅读更多...
《隐私计算简易速速上手小册》第2章：关键技术介绍（2024 最新版）

《隐私计算简易速速上手小册》第2章：关键技术介绍（2024 最新版）

文章目录 2.1 同态加密2.1.1 基础知识2.1.2 主要案例：云计算数据分析2.1.3 拓展案例 1：医疗数据分析2.1.4 拓展案例 2：金融风险评估 2.2 安全多方计算（SMC）2.2.1 基础知识2.2.2 主要案例：跨机构金融数据共享…
阅读更多...
【医学影像】LIDC-IDRI数据集的无痛制作

【医学影像】LIDC-IDRI数据集的无痛制作

LIDC-IDRI数据集制作 0.下载0.0 链接汇总0.1 步骤 1.合成CT图reference 0.下载 0.0 链接汇总 LIDC-IDRI官方网址：https://www.cancerimagingarchive.net/nbia-search/?CollectionCriteriaLIDC-IDRINBIA Data Retriever 下载链接：https://wiki.canceri…
阅读更多...
【王道数据结构】【chapter7查找】【P308t5】

【王道数据结构】【chapter7查找】【P308t5】

试编写一个算法&#xff0c;判断给定的二叉树是否是二叉排序树 #include <iostream> #include <queue> typedef struct node{int data;struct node* left;struct node* right; }node,*pnode;pnode buynode(int x) {pnode tmp(pnode) malloc(sizeof (node));tmp->…
阅读更多...
SpringMVC 学习（九）之拦截器

SpringMVC 学习（九）之拦截器

目录 1 拦截器介绍 2 创建一个拦截器类 3 配置拦截器 1 拦截器介绍 在 SpringMVC 中&#xff0c;拦截器 (Interceptor) 是一种用于拦截 HTTP 请求并在请求处理之前或之后执行自定义逻辑的组件。拦截器可以用于实现以下功能&#xff1a; 权限验证&#xff1a;在请求处理之前…
阅读更多...
SORA 到底是什么？如何用bitget wallet购买？

SORA 到底是什么？如何用bitget wallet购买？

什么是SORA&#xff1f; SORA 是一种模因币&#xff0c;灵感来自 OpenAI 最新的人工智能模型 Sora&#xff0c;它巧妙地根据文本输入生成视频。 SORA 诞生于加密社区内人工智能项目的热潮中&#xff0c;利用 OpenAI 的公告推出了一种独特且时尚的数字资产。正如 memecoin 网站…
阅读更多...
文件操作（IO技术，重要！！！）

文件操作（IO技术，重要！！！）

1、文本文件和二进制文件 按文件中数据组织形式&#xff0c;我们把文件分为文本文件和二进制文件两大类&#xff0c; 1. 文本文件 文本文件存储的是普通“字符”文本&#xff0c;默认为unicode字符集&#xff08;两个字节表示一个字符&#xff0c;65535&#xff09;&#xff0c…
阅读更多...
python｜闲谈2048小游戏和数组的旋转及翻转和转置

python｜闲谈2048小游戏和数组的旋转及翻转和转置

目录 2048 生成数组 n阶方阵 方阵旋转 顺时针旋转 逆时针旋转 mxn矩阵 矩阵旋转 测试代码 测试结果 翻转和转置 2048 《2048》是一款比较流行​的数字游戏​&#xff0c;最早于2014年3月20日发行。原版2048由Gabriele Cirulli首先在GitHub上发布&#xff0c;后被移…
阅读更多...
【MQ05】异常消息处理

【MQ05】异常消息处理

异常消息处理 上节课我们已经学习到了消息的持久化和确认相关的内容。但是&#xff0c;光有这些还不行&#xff0c;如果我们的消费者出现问题了&#xff0c;无法确认&#xff0c;或者直接报错产生异常了&#xff0c;这些消息要怎么处理呢&#xff1f;直接丢弃&#xff1f;这就是…
阅读更多...
浅谈 Linux 网络编程 - 网络字节序

浅谈 Linux 网络编程 - 网络字节序

文章目录 前言核心知识关于 小端法关于 大端法网络字节序的转换 函数 前言 在进行 socket 网络编程时&#xff0c;会用到字节流的转换函数、例如 inet_pton、htons 等&#xff0c;那么为什么要用到这些函数呢&#xff0c;本篇主要就是对这部分进行介绍。 核心知识 重点需要记…
阅读更多...
韩国突发：将批准比特币ETF

韩国突发：将批准比特币ETF

作者&#xff1a;秦晋 韩国两党宣布将批准比特币ETF。比特币也再次成为竞选的宠儿。 4月10日&#xff0c;韩国将迎来每隔4年而进行的一次立法大选。在大选之前&#xff0c;现执政党与反对党都承诺将批准比特币ETF。 我们知道&#xff0c;比特币的主要受众群体以年轻人居多。此前…
阅读更多...
idea打包报错，clean、package报错

idea打包报错，clean、package报错

一、idea在打包时&#xff0c;点击clean或package报错如下&#xff1a; Error running ie [clean]: No valid Maven installation found. Either set the home directory in the configuration dialog or set the M2_HOME environment variable on your system. 示例图&#xf…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023