教程集 > Golang编程 > golang教程 > 正文 client-go 之 Indexer 的理解

client-go 之 Indexer 的理解

发布时间：2022-02-13 编辑：jiaochengji.com

教程集为您提供client-go 之 Indexer 的理解等资源，欢迎您收藏本站，我们将为您提供最新的client-go 之 Indexer 的理解资源

前面我们讲到 DeltaFIFO 中的元素通过 Pop 函数弹出后，在指定的回调函数中将元素添加到了 Indexer 中。Indexer 是什么？字面意思是索引器，它就是 Informer 中的 LocalStore 部分，我们可以和数据库进行类比，数据库是建立在存储之上的，索引也是构建在存储之上，只是和数据做了一个映射，使得按照某些条件查询速度会非常快，所以说 Indexer 本身也是一个存储，只是它在存储的基础上扩展了索引功能。从 Indexer 接口的定义可以证明这一点：

在去查看 Indexer 的接口具体实现之前，我们需要了解 Indexer 中几个非常重要的概念：<code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">Indices</code>、<code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">Index</code>、<code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">Indexers</code> 及 <code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">IndexFunc</code>。

这4个数据结构的命名非常容易让大家混淆，直接查看源码也不是那么容易的。这里我们来仔细解释下。首先什么叫索引，索引就是为了快速查找的，比如我们需要查找某个节点上的所有 Pod，那就让 Pod 按照节点名称排序列举出来，对应的就是 Index 这个类型，具体的就是 <code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">map[node]sets.pod</code>，但是如何去查找可以有多种方式，就是上面的 Indexers 这个类型的作用。我们可以用一个比较具体的示例来解释他们的关系和含义，如下所示：

<pre style="margin-top:10px;margin-bottom:10px;padding:0px;max-width:100%;"><span style="margin:0px 0px -7px;padding:0px;max-width:100%;background-image:url("https://mmbiz.qpic.cn/mmbiz_png/z9BgVMEm7YtQQPoYe5dS4oUtdKQMB6Xo8l8uZLXrwJ1JJeF4zaCLpgyDuNTjU1gcv0o0VpCerB9zl7ics532hpw/640?wx_fmt=png");background-position:10px 10px;background-repeat:no-repeat;height:30px;width:524px;"/><code style="margin:0px;padding:15px 16px 16px;max-width:100%;color:rgb(171,178,191);font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;font-size:12px;">package main

import (
"fmt"

v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/api/meta"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/client-go/tools/cache"
)

const (
NamespaceIndexName = "namespace"
NodeNameIndexName = "nodeName"
)

func NamespaceIndexFunc(obj interface{}) ([]string, error) {
m, err := meta.Accessor(obj)
if err != nil {
 return []string{""}, fmt.Errorf("object has no meta: %v", err)
}
return []string{m.GetNamespace()}, nil
}

func NodeNameIndexFunc(obj interface{}) ([]string, error) {
pod, ok := obj.(*v1.Pod)
if !ok {
 return []string{}, nil
}
return []string{pod.Spec.NodeName}, nil
}

func main() {
index := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{
 NamespaceIndexName: NamespaceIndexFunc,
 NodeNameIndexName: NodeNameIndexFunc,
})

pod1 := &v1.Pod{
 ObjectMeta: metav1.ObjectMeta{
 Name: "index-pod-1",
 Namespace: "default",
 },
 Spec: v1.PodSpec{NodeName: "node1"},
}
pod2 := &v1.Pod{
 ObjectMeta: metav1.ObjectMeta{
 Name: "index-pod-2",
 Namespace: "default",
 },
 Spec: v1.PodSpec{NodeName: "node2"},
}
pod3 := &v1.Pod{
 ObjectMeta: metav1.ObjectMeta{
 Name: "index-pod-3",
 Namespace: "kube-system",
 },
 Spec: v1.PodSpec{NodeName: "node2"},
}

_ = index.Add(pod1)
_ = index.Add(pod2)
_ = index.Add(pod3)

// ByIndex 两个参数：IndexName（索引器名称）和 indexKey（需要检索的key）
pods, err := index.ByIndex(NamespaceIndexName, "default")
if err != nil {
 panic(err)
}
for _, pod := range pods {
 fmt.Println(pod.(*v1.Pod).Name)
}

fmt.Println("==========================")

pods, err = index.ByIndex(NodeNameIndexName, "node2")
if err != nil {
 panic(err)
}
for _, pod := range pods {
 fmt.Println(pod.(*v1.Pod).Name)
}

}

// 输出结果为：
index-pod-1
index-pod-2
==========================
index-pod-2
index-pod-3
</code></pre>

在上面的示例中首先通过 NewIndexer 函数实例化 Indexer 对象，第一个参数就是用于计算资源对象键的函数，这里我们使用的是 <code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">MetaNamespaceKeyFunc</code> 这个默认的对象键函数；第二个参数是 Indexers，也就是存储索引器，上面我们知道 <code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">Indexers</code> 的定义为 <code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">map[string]IndexFunc</code>，为什么要定义成一个 map 呢？我们可以类比数据库中，我们要查询某项数据，索引的方式是不是多种多样啊？为了扩展，Kubernetes 中就使用一个 map 来存储各种各样的存储索引器，至于存储索引器如何生成，就使用一个 <code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">IndexFunc</code> 暴露出去，给使用者自己实现即可。

这里我们定义的了两个索引键生成函数：<code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">NamespaceIndexFunc</code> 与 <code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">NodeNameIndexFunc</code>，一个根据资源对象的命名空间来进行索引，一个根据资源对象所在的节点进行索引。然后定义了3个 Pod，前两个在 default 命名空间下面，另外一个在 kube-system 命名空间下面，然后通过 <code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">index.Add</code> 函数添加这3个 Pod 资源对象。然后通过 <code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">index.ByIndex</code> 函数查询在名为 <code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">namespace</code> 的索引器下面匹配索引键为 <code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">default</code> 的 Pod 列表。也就是查询 default 这个命名空间下面的所有 Pod，这里就是前两个定义的 Pod。

对上面的示例如果我们理解了，那么就很容易理解上面定义的4个数据结构了：

<ul style="margin-top:8px;margin-bottom:8px;padding:0px 0px 0px 25px;max-width:100%;"><li>IndexFunc：索引器函数，用于计算一个资源对象的索引值列表，上面示例是指定命名空间为索引值结果，当然我们也可以根据需求定义其他的，比如根据 Label 标签、Annotation 等属性来生成索引值列表。</li><li>Index：存储数据，对于上面的示例，我们要查找某个命名空间下面的 Pod，那就要让 Pod 按照其命名空间进行索引，对应的 Index 类型就是<code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">map[namespace]sets.pod</code>。</li><li>Indexers：存储索引器，key 为索引器名称，value 为索引器的实现函数，上面的示例就是 <code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">map["namespace"]MetaNamespaceIndexFunc</code>。</li><li>Indices：存储缓存器，key 为索引器名称，value 为缓存的数据，对于上面的示例就是 <code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">map["namespace"]map[namespace]sets.pod</code>。</li></ul>

可能最容易混淆的是 Indexers 和 Indices 这两个概念，因为平时很多时候我们没有怎么区分二者的关系，这里我们可以这样理解：Indexers 是存储索引（生成索引键）的，Indices 里面是存储的真正的数据（对象键），这样可能更好理解。按照上面的理解我们可以得到上面示例的索引数据如下所示：

上面我们理解了 Indexer 中的几个重要的数据类型，下面我们来看下 Indexer 接口的具体实现 cache，位于文件 <code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">k8s.io/client-go/tools/cache/store.go</code> 中：

我们可以看到这个 cache 包含一个 <code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">ThreadSafeStore</code> 的属性，这是一个并发安全的存储，因为是存储，所以自然就有存储相关的增、删、改、查等操作，Indexer 就是在 ThreadSafeMap 基础上进行封装的，实现了索引相关的功能。接下来我们先来看看 ThreadSafeStore 的定义，位于 <code style="margin:3px;padding:3px;max-width:100%;font-size:14px;font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;color:rgb(155,110,35);background-color:rgb(255,245,227);">k8s.io/client-go/tools/cache/thread_safe_store.go</code> 文件中：

从接口的定义可以看出 ThreadSafeStore 和 Index 基本上差不多，但还是有一些区别的，这个接口是需要通过对象键来进行索引的。接下来我们来看看这个接口的具体实现 threadSafeMap 的定义：

不要把索引键和对象键搞混了，索引键是用于对象快速查找的；对象键是对象在存储中的唯一命名，对象是通过名字对象的方式存储的。接下来我们来仔细看下接口的具体实现，首先还是比较简单的 Add、Delete、Update 几个函数的实现：

可以看到基本的实现比较简单，就是添加、更新、删除对象数据后，然后更新或删除对应的索引，所以我们需要查看下更新或删除索引的具体实现：

<pre style="margin-top:10px;margin-bottom:10px;padding:0px;max-width:100%;"><span style="margin:0px 0px -7px;padding:0px;max-width:100%;background-image:url("https://mmbiz.qpic.cn/mmbiz_png/z9BgVMEm7YtQQPoYe5dS4oUtdKQMB6Xo8l8uZLXrwJ1JJeF4zaCLpgyDuNTjU1gcv0o0VpCerB9zl7ics532hpw/640?wx_fmt=png");background-position:10px 10px;background-repeat:no-repeat;height:30px;width:524px;"/><code style="margin:0px;padding:15px 16px 16px;max-width:100%;color:rgb(171,178,191);font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;font-size:12px;">// k8s.io/client-go/tools/cache/thread_safe_store.go

// updateIndices 更新索引
func (c *threadSafeMap) updateIndices(oldObj interface{}, newObj interface{}, key string) {
// 如果有旧的对象，需要先从索引中删除这个对象
if oldObj != nil {
 c.deleteFromIndices(oldObj, key)
}
 // 循环所有的索引器
for name, indexFunc := range c.indexers {
 // 获取对象的索引键
 indexValues, err := indexFunc(newObj)
 if err != nil {
 panic(fmt.Errorf("unable to calculate an index entry for key %q on index %q: %v", key, name, err))
 }
 // 得到当前索引器的索引
 index := c.indices[name]
 if index == nil {
 // 没有对应的索引，则初始化一个索引
 index = Index{}
 c.indices[name] = index
 }
 // 循环所有的索引键
 for _, indexValue := range indexValues {
 // 得到索引键对应的对象键列表
 set := index[indexValue]
 if set == nil {
 // 没有对象键列表则初始化一个空列表
 set = sets.String{}
 index[indexValue] = set
 }
 // 将对象键插入到集合中，方便索引
 set.Insert(key)
 }
}
}

// deleteFromIndices 删除对象索引
func (c *threadSafeMap) deleteFromIndices(obj interface{}, key string) {
 // 循环所有的索引器
for name, indexFunc := range c.indexers {
 // 获取删除对象的索引键列表
 indexValues, err := indexFunc(obj)
 if err != nil {
 panic(fmt.Errorf("unable to calculate an index entry for key %q on index %q: %v", key, name, err))
 }
 // 获取当前索引器的索引
 index := c.indices[name]
 if index == nil {
 continue
 }
 // 循环所有索引键
 for _, indexValue := range indexValues {
 // 获取索引键对应的对象键列表
 set := index[indexValue]
 if set != nil {
 // 从对象键列表中删除当前要删除的对象键
 set.Delete(key)

 // 如果当集合为空的时候不删除set，那么具有高基数的短生命资源的 indices 会导致未使用的空集合随时间增加内存。
 // `kubernetes/kubernetes/issues/84959`.
 if len(set) == 0 {
 delete(index, indexValue)
 }
 }
 }
}
}
</code></pre>

添加索引和删除索引的实现都挺简单的，其实主要还是要对 indices、indexs 这些数据结构非常了解，这样就非常容易了，我们可以将 indexFunc 当成当前对象的命名空间来看待，这样对于上面的索引更新和删除的理解就肯定没问题了。

然后接下来就是几个查询相关的接口实现：

<pre style="margin-top:10px;margin-bottom:10px;padding:0px;max-width:100%;"><span style="margin:0px 0px -7px;padding:0px;max-width:100%;background-image:url("https://mmbiz.qpic.cn/mmbiz_png/z9BgVMEm7YtQQPoYe5dS4oUtdKQMB6Xo8l8uZLXrwJ1JJeF4zaCLpgyDuNTjU1gcv0o0VpCerB9zl7ics532hpw/640?wx_fmt=png");background-position:10px 10px;background-repeat:no-repeat;height:30px;width:524px;"/><code style="margin:0px;padding:15px 16px 16px;max-width:100%;color:rgb(171,178,191);font-family:'Operator Mono', Consolas, Monaco, Menlo, monospace;font-size:12px;">// k8s.io/client-go/tools/cache/thread_safe_store.go

// 获取对象
func (c *threadSafeMap) Get(key string) (item interface{}, exists bool) {
c.lock.RLock() // 只需要读锁
defer c.lock.RUnlock()
 // 直接从 map 中读取值
item, exists = c.items[key]
return item, exists
}

// 对象列举
func (c *threadSafeMap) List() []interface{} {
c.lock.RLock()
defer c.lock.RUnlock()
list := make([]interface{}, 0, len(c.items))
for _, item := range c.items {
 list = append(list, item)
}
return list
}

// 返回 threadSafeMap 中所有的对象键列表
func (c *threadSafeMap) ListKeys() []string {
c.lock.RLock()
defer c.lock.RUnlock()
list := make([]string, 0, len(c.items))
for key := range c.items {
 list = append(list, key)
}
return list
}

// 替换所有对象，相当于重新构建索引
func (c *threadSafeMap) Replace(items map[string]interface{}, resourceVersion string) {
c.lock.Lock()
defer c.lock.Unlock()
 // 直接覆盖之前的对象
c.items = items

// 重新构建索引
c.indices = Indices{}
for key, item := range c.items {
 // 更新元素的索引
 c.updateIndices(nil, item, key)
}
}
</code></pre>

然后接下来就是和索引相关的几个接口实现，第一个就是 Index 函数：

上一篇：百度网盘开放平台 Go SDK 下一篇：Go Modules 的使用

[关闭]

client-go 之 Indexer 的理解

最近更新

浏览排行