記得大學剛畢業那年看了侯俊傑的《深入淺出MFC》，就對深入淺出這四個字特別偏好，並且成為了自己對技術的要求標準——對於技術的理解要足夠的深刻以至於可以用很淺顯的道理給別人講明白。以下內容為個人見解，如有雷同，純屬巧合，如有錯誤，煩請指正。

本文基於kubernetes1.11版本，後續會根據kubernetes版本更新及時更新文件，所有程式碼引用為了簡潔都去掉了日誌列印相關的程式碼，儘量只保留有價值的內容。

目錄

Indexer功能介紹

Indexer實現之cache

ThreadSafeStore

cache的實現

kubernetes中主要的索引函式

總結

Indexer功能介紹

Informer是client-go的重要組成部分，在瞭解client-go之前，瞭解一下Informer的實現是很有必要的，下面引用了官方的圖，可以看到Informer在client-go中的位置。

由於Informer比較龐大，所以我們把它拆解成接獨立的模組分析，本文分析的就是Indexer模組。Indexer是什麼，從字面上看是索引器，他所在的位置就是Informer的LocalStore。肯定有人會問索引和儲存有啥關係，那資料庫建索引不也是儲存和索引建立了關係麼？索引構建在儲存之上，使得按照某些條件查詢速度會非常快。我先從程式碼上證實client-go中的Indexer就是儲存：

1. // 程式碼源自client-go/tools/cache/index.go

2. type Indexer interface {

3. Store // 此處繼承了Store這個interface，定義在cliet-go/tool/cache/store.go中

4. ......

5. }

Indexer在Store基礎上擴充套件了索引能力，那Indexer是如何實現索引的呢?讓我們來看看幾個非常關鍵的型別：

1. // 程式碼源自client-go/tools/cache/index.go

2. type IndexFunc func(obj interface{}) ([]string, error) // 計算索引的函式，傳入物件，輸出字串索引，注意是陣列哦！

3. type Indexers map[string]IndexFunc // 計算索引的函式有很多，用名字分類

4. type Indices map[string]Index // 由於有多種計算索引的方式，那就又要按照計算索引的方式組織索引

5. type Index map[string]sets.String // 每種計算索引的方式會輸出多個索引(陣列)

6. // 而多個目標可能會算出相同索引，所以就有了這個型別

我相信很多人初次(不要看我的註釋)看到上面的定義肯定懵逼了，不用說別的，就型別命名根本看不出是幹啥的，而且還相似~我在這裡給大家解釋一下定義這些型別的目的。何所謂索引，索引目的就是為了快速查詢。比如，我們需要查詢某個節點上的所有Pod，那就要Pod按照節點名稱排序，對應上面的Index型別就是map[nodename]sets.podname。我們可能有很多種查詢方式，這就是Indexers這個型別作用了。下面的圖幫助讀者理解，不代表真正實現：

Indexers和Indices都是按照IndexFunc(名字)分組， 每個IndexFunc輸出多個IndexKey，產生相同IndexKey的多個物件儲存在一個集合中。注意：上圖中不代表Indexers和Indices都指向了同一個資料，只是示意都用相同的IndexFunc的名字。

為了方便後面內容的開展，我們先統一一些概念：

1. IndexFunc1.....這些都是索引函式的名稱，我們稱之為索引類，大概意思就是把索引分類了；
2. IndexKey1....這些是同一個物件在同一個索引類中的多個索引鍵值，我們稱為索引鍵，切記索引鍵有多個；
3. ObjKey1.....這些是物件鍵，每個物件都有唯一的名稱；

有了上面的基礎，我們再來看看Indexer與索引相關的介面都定義了哪些？

1. // 程式碼源自client-go/tools/cache/index.go

2. type Indexer interface {

3. // 集成了儲存的介面，前面提到了，後面會有詳細說明

4. Store

5. // indexName索引類，obj是物件，計算obj在indexName索引類中的索引鍵，通過索引鍵把所有的物件取出來

6. // 基本就是獲取符合obj特徵的所有物件，所謂的特徵就是物件在索引類中的索引鍵

7. Index(indexName string, obj interface{}) ([]interface{}, error)

8. // indexKey是indexName索引類中一個索引鍵，函式返回indexKey指定的所有物件鍵

9. // 這個物件鍵是Indexer內唯一的，在新增的時候會計算，後面講具體Indexer例項的會講解

10. IndexKeys(indexName, indexKey string) ([]string, error)

11. // 獲取indexName索引類中的所有索引鍵

12. ListIndexFuncValues(indexName string) []string

13. // 這個函式和Index類似，只是返回值不是物件鍵，而是所有物件

14. ByIndex(indexName, indexKey string) ([]interface{}, error)

15. // 返回Indexers

16. GetIndexers() Indexers

17. // 新增Indexers，就是增加更多的索引分類

18. AddIndexers(newIndexers Indexers) error

19. }

我相信通過我的註釋很多人已經對Indexer有了初步認識，我們再來看看Store這個interface有哪些介面：

1. // 程式碼源自client-go/tools/cache/store.go

2. type Store interface {

3. // 新增物件

4. Add(obj interface{}) error

5. // 更新物件

6. Update(obj interface{}) error

7. // 刪除物件

8. Delete(obj interface{}) error

9. // 列舉物件

10. List() []interface{}

11. // 列舉物件鍵

12. ListKeys() []string

13. // 返回obj相同物件鍵的物件，物件鍵是通過物件計算出來的字串

14. Get(obj interface{}) (item interface{}, exists bool, err error)

15. // 通過物件鍵獲取物件

16. GetByKey(key string) (item interface{}, exists bool, err error)

17. // 用[]interface{}替換Store儲存的所有物件，等同於刪除全部原有物件在逐一新增新的物件

18. Replace([]interface{}, string) error

19. // 重新同步

20. Resync() error

21. }

從Store的抽象來看，要求每個物件都要有唯一的鍵，至於鍵的計算方式就看具體實現了。我們看了半天的各種抽象，是時候講解一波具體實現了。

Indexer實現之cache

cache是Indexer的一種非常經典的實現，所有的物件快取在記憶體中，而且從cache這個型別的名稱來看屬於包內私有型別，外部無法直接使用，只能通過專用的函式建立。其實cache的定義非常簡單，如下所以：

1. // 程式碼源自client-go/tools/cache/store.go

2. type cache struct {

3. cacheStorage ThreadSafeStore // 執行緒安全的儲存

4. keyFunc KeyFunc // 計算物件鍵的函式

5. }

6. // 計算物件鍵的函式

7. type KeyFunc func(obj interface{}) (string, error)

這裡可以看出來cache有一個計算物件鍵的函式，建立cache物件的時候就要指定這個函數了。

ThreadSafeStore

從cache的定義來看，所有的功能基本是通過ThreadSafeStore這個型別實現的，keyFunc就是用來計算物件鍵的。所以，我們在分析cache之前，分析ThreadSafeStore是非常重要的，接下來就看看這個型別是如何定義的：

1. // 程式碼源自client-go/tools/cache/thread_safe_store.go

2. type ThreadSafeStore interface {

3. Add(key string, obj interface{})

4. Update(key string, obj interface{})

5. Delete(key string)

6. Get(key string) (item interface{}, exists bool)

7. List() []interface{}

8. ListKeys() []string

9. Replace(map[string]interface{}, string)

10. Index(indexName string, obj interface{}) ([]interface{}, error)

11. IndexKeys(indexName, indexKey string) ([]string, error)

12. ListIndexFuncValues(name string) []string

13. ByIndex(indexName, indexKey string) ([]interface{}, error)

14. GetIndexers() Indexers

15. AddIndexers(newIndexers Indexers) error

16. Resync() error

17. }

我為什麼沒有對ThreadSafeStore做註釋呢？乍一看和Indexer這個itnerface基本一樣，但還是有差別的，就是跟儲存相關的介面。Indexer因為繼承了Store，儲存相關的增刪改查輸入都是物件，而ThreadSafeStore是需要提供物件鍵的。所以ThreadSafeStore和Indexer基本一樣，也就沒必要再寫一遍註釋，我們可以把精力主要放在具體的實現類上：

1. // 程式碼源自client-go/tools/cache/thread_safe_store.go

2. type threadSafeMap struct {

3. lock sync.RWMutex // 讀寫鎖，畢竟讀的多寫的少，讀寫鎖效能要更好

4. items map[string]interface{} // 儲存物件的map，物件鍵:物件

5. indexers Indexers // 這個不用多解釋了把，用於計算索引鍵的函式map

6. indices Indices // 快速索引表，通過索引可以快速找到物件鍵，然後再從items中取出物件

7. }

看了具體的實現類是不是感覺很簡單？其實就是很簡單，如果沒有經過系統的梳理，如此簡單的實現也不見的很容易看明白。我還是要在此強調一次，索引鍵和物件鍵是兩個重要概念，索引鍵是用於物件快速查詢的，經過索引建在map中排序查詢會更快；物件鍵是為物件在儲存中的唯一命名的，物件是通過名字+物件的方式儲存的。

後續內容會簡單很多，所以會把多個函式放在一起註釋，下面就是和儲存相關的函式的統一說明：

1. // 程式碼源自client-go/tools/cache/thread_safe_store.go

2. // 新增物件函式

3. func (c *threadSafeMap) Add(key string, obj interface{}) {

4. // 加鎖，因為是寫操作，所以是全部互斥的那種

5. c.lock.Lock()

6. defer c.lock.Unlock()

7. // 把老的物件取出來

8. oldObject := c.items[key]

9. // 寫入新的物件

10. c.items[key] = obj

11. // 由於物件的新增就要更新索引

12. c.updateIndices(oldObject, obj, key)

13. }

14. // 更新物件函式，和新增物件一模一樣，所以就不解釋了，為啥Add函式不直接呼叫Update呢？

15. func (c *threadSafeMap) Update(key string, obj interface{}) {

16. c.lock.Lock()

17. defer c.lock.Unlock()

18. oldObject := c.items[key]

19. c.items[key] = obj

20. c.updateIndices(oldObject, obj, key)

21. }

22. // 刪除物件

23. func (c *threadSafeMap) Delete(key string) {

24. // 加鎖，因為是寫操作，所以是全部互斥的那種

25. c.lock.Lock()

26. defer c.lock.Unlock()

27. // 判斷物件是否存在？

28. if obj, exists := c.items[key]; exists {

29. // 刪除物件的索引

30. c.deleteFromIndices(obj, key)

31. // 刪除物件本身

32. delete(c.items, key)

33. }

34. }

35. // 獲取物件

36. func (c *threadSafeMap) Get(key string) (item interface{}, exists bool) {

37. // 此處只用了讀鎖

38. c.lock.RLock()

39. defer c.lock.RUnlock()

40. // 利用物件鍵取出物件

41. item, exists = c.items[key]

42. return item, exists

43. }

44. // 列舉物件

45. func (c *threadSafeMap) List() []interface{} {

46. // 此處只用了讀鎖

47. c.lock.RLock()

48. defer c.lock.RUnlock()

49. // 直接遍歷物件map就可以了

50. list := make([]interface{}, 0, len(c.items))

51. for _, item := range c.items {

52. list = append(list, item)

53. }

54. return list

55. }

56. // 列舉物件鍵

57. func (c *threadSafeMap) ListKeys() []string {

58. // 此處只用了讀鎖

59. c.lock.RLock()

60. defer c.lock.RUnlock()

61. // 同樣是遍歷物件map，但是隻輸出物件鍵

62. list := make([]string, 0, len(c.items))

63. for key := range c.items {

64. list = append(list, key)

65. }

66. return list

67. }

68. // 取代所有物件，相當於重新構造了一遍threadSafeMap

69. func (c *threadSafeMap) Replace(items map[string]interface{}, resourceVersion string) {

70. // 此處必須要用全域性鎖，因為有寫操作

71. c.lock.Lock()

72. defer c.lock.Unlock()

73. // 直接覆蓋以前的物件

74. c.items = items

75.  

76. // 重建索引

77. c.indices = Indices{}

78. for key, item := range c.items {

79. c.updateIndices(nil, item, key)

80. }

81. // 發現沒有，resourceVersion此處沒有用到，估計是其他的Indexer實現有用

82. }

下面就是跟索引相關的函數了，也是我主要講解的內容，所以每個函式都是獨立註釋的，我們一個一個的過：

1. // 程式碼源自client-go/tools/cache/thread_safe_store.go

2. // 這個函式就是通過指定的索引函式計算物件的索引鍵，然後把索引鍵的物件全部取出來

3. func (c *threadSafeMap) Index(indexName string, obj interface{}) ([]interface{}, error) {

4. // 只讀，所以用讀鎖

5. c.lock.RLock()

6. defer c.lock.RUnlock()

7. // 取出indexName這個分類索引函式

8. indexFunc := c.indexers[indexName]

9. if indexFunc == nil {

10. return nil, fmt.Errorf("Index with name %s does not exist", indexName)

11. }

12. // 計算物件的索引鍵

13. indexKeys, err := indexFunc(obj)

14. if err != nil {

15. return nil, err

16. }

17. // 取出indexName這個分類所有索引

18. index := c.indices[indexName]

19.  

20. // 返回物件的物件鍵的集合

21. returnKeySet := sets.String{}

22. // 遍歷剛剛計算出來的所有索引鍵

23. for _, indexKey := range indexKeys {

24. // 取出索引鍵的所有物件鍵

25. set := index[indexKey]

26. // 把所有的物件鍵輸出到物件鍵的集合中

27. for _, key := range set.UnsortedList() {

28. returnKeySet.Insert(key)

29. }

30. }

31. // 通過物件鍵逐一的把物件取出

32. list := make([]interface{}, 0, returnKeySet.Len())

33. for absoluteKey := range returnKeySet {

34. list = append(list, c.items[absoluteKey])

35. }

36.  

37. return list, nil

38. }

這個函式比較有意思，利用一個物件計算出來的索引鍵，然後把所有具備這些索引鍵的物件全部取出來，為了方便理解我都是這樣告訴自己的：比如取出一個Pod所在節點上的所有Pod，這樣理解就會非常方便，但是kubernetes可能就不這麼用。如果更抽象一點，就是符合物件某些特徵的所有物件，而這個特徵就是我們指定的索引函式計算出來的。

好啦，下一個函式：

1. // 程式碼源自client-go/tools/cache/thread_safe_store.go

2. // 這個函式和上面的函式基本一樣，只是索引鍵不用再計算了，使用者提供

3. func (c *threadSafeMap) ByIndex(indexName, indexKey string) ([]interface{}, error) {

4. // 同樣是讀鎖

5. c.lock.RLock()

6. defer c.lock.RUnlock()

7. // 判斷indexName這個索引分類是否存在

8. indexFunc := c.indexers[indexName]

9. if indexFunc == nil {

10. return nil, fmt.Errorf("Index with name %s does not exist", indexName)

11. }

12. // 取出索引分類的所有索引

13. index := c.indices[indexName]

14. // 再出去索引鍵的所有物件鍵

15. set := index[indexKey]

16. // 遍歷物件鍵輸出

17. list := make([]interface{}, 0, set.Len())

18. for _, key := range set.List() {

19. list = append(list, c.items[key])

20. }

21.  

22. return list, nil

23. }

 這個函式相比於上一個函式功能略微簡單一點，獲取的是一個具體索引鍵的全部物件。Come on，沒幾個函數了！

1. // 程式碼源自client-go/tools/cache/thread_safe_store.go

2. // 你會發現這個函式和ByIndex()基本一樣，只是輸出的是物件鍵

3. func (c *threadSafeMap) IndexKeys(indexName, indexKey string) ([]string, error) {

4. // 同樣是讀鎖

5. c.lock.RLock()

6. defer c.lock.RUnlock()

7. // 判斷indexName這個索引分類是否存在

8. indexFunc := c.indexers[indexName]

9. if indexFunc == nil {

10. return nil, fmt.Errorf("Index with name %s does not exist", indexName)

11. }

12. // 取出索引分類的所有索引

13. index := c.indices[indexName]

14. // 直接輸出索引鍵內的所有物件鍵

15. set := index[indexKey]

16. return set.List(), nil

17. }

還有最後一個(其他的對外介面函式太簡單了，讀者自行分析就好了):

1. // 程式碼源自client-go/tools/cache/thread_safe_store.go

2. // 這個函式用來獲取索引分類內的所有索引鍵的

3. func (c *threadSafeMap) ListIndexFuncValues(indexName string) []string {

4. // 依然是讀鎖

5. c.lock.RLock()

6. defer c.lock.RUnlock()

7. // 獲取索引分類的所有索引

8. index := c.indices[indexName]

9. // 直接遍歷後輸出索引鍵

10. names := make([]string, 0, len(index))

11. for key := range index {

12. names = append(names, key)

13. }

14. return names

15. }

至於AddIndexers()和GetIndexers()因為沒有難度，而且不影響理解核心邏輯，所以此處不再浪費文字了。看了半天程式碼是不是感覺缺點什麼？為什麼沒有看到索引是如何組織的？那就對了，因為還有兩個最為重要的私有函式沒有分析呢！

1. // 程式碼源自client-go/tools/cache/thread_safe_store.go

2. // 當有物件新增或者更新是，需要更新索引，因為代用該函式的函式已經加鎖了，所以這個函式沒有加鎖操作

3. func (c *threadSafeMap) updateIndices(oldObj interface{}, newObj interface{}, key string) {

4. // 在新增和更新的時候都會獲取老物件，如果存在老物件，那麼就要刪除老物件的索引，後面有說明

5. if oldObj != nil {

6. c.deleteFromIndices(oldObj, key)

7. }

8. // 遍歷所有的索引函式，因為要為物件在所有的索引分類中建立索引鍵

9. for name, indexFunc := range c.indexers {

10. // 計算索引鍵

11. indexValues, err := indexFunc(newObj)

12. if err != nil {

13. panic(fmt.Errorf("unable to calculate an index entry for key %q on index %q: %v", key, name, err))

14. }

15. // 獲取索引分類的所有索引

16. index := c.indices[name]

17. if index == nil {

18. // 為空說明這個索引分類還沒有任何索引

19. index = Index{}

20. c.indices[name] = index

21. }

22. // 遍歷物件的索引鍵，上面剛剛用索引函式計算出來的

23. for _, indexValue := range indexValues {

24. // 找到索引鍵的物件集合

25. set := index[indexValue]

26. // 為空說明這個索引鍵下還沒有物件

27. if set == nil {

28. // 建立物件鍵集合

29. set = sets.String{}

30. index[indexValue] = set

31. }

32. // 把物件鍵新增到集合中

33. set.Insert(key)

34. }

35. }

36. }

37. // 這個函式用於刪除物件的索引的

38. func (c *threadSafeMap) deleteFromIndices(obj interface{}, key string) {

39. // 遍歷索引函式，也就是把所有索引分類

40. for name, indexFunc := range c.indexers {

41. // 計算物件的索引鍵

42. indexValues, err := indexFunc(obj)

43. if err != nil {

44. panic(fmt.Errorf("unable to calculate an index entry for key %q on index %q: %v", key, name, err))

45. }

46. // 獲取索引分類的所有索引

47. index := c.indices[name]

48. if index == nil {

49. continue

50. }

51. // 遍歷物件的索引鍵

52. for _, indexValue := range indexValues {

53. 把物件從索引鍵指定對物件集合刪除

54. set := index[indexValue]

55. if set != nil {

56. set.Delete(key)

57. }

58. }

59. }

60. }

cache的實現

因為cache就是在ThreadSafeStore的再封裝，實現也非常簡單，我不做過多說明，只把程式碼羅列出來，讀者一看便知。

1. // 程式碼源自client-go/tools/cache/store.go

2. func (c *cache) Add(obj interface{}) error {

3. key, err := c.keyFunc(obj)

4. if err != nil {

5. return KeyError{obj, err}

6. }

7. c.cacheStorage.Add(key, obj)

8. return nil

9. }

10. func (c *cache) Update(obj interface{}) error {

11. key, err := c.keyFunc(obj)

12. if err != nil {

13. return KeyError{obj, err}

14. }

15. c.cacheStorage.Update(key, obj)

16. return nil

17. }

18. func (c *cache) Delete(obj interface{}) error {

19. key, err := c.keyFunc(obj)

20. if err != nil {

21. return KeyError{obj, err}

22. }

23. c.cacheStorage.Delete(key)

24. return nil

25. }

26. func (c *cache) List() []interface{} {

27. return c.cacheStorage.List()

28. }

29. func (c *cache) ListKeys() []string {

30. return c.cacheStorage.ListKeys()

31. }

32. func (c *cache) GetIndexers() Indexers {

33. return c.cacheStorage.GetIndexers()

34. }

35. func (c *cache) Index(indexName string, obj interface{}) ([]interface{}, error) {

36. return c.cacheStorage.Index(indexName, obj)

37. }

38. func (c *cache) IndexKeys(indexName, indexKey string) ([]string, error) {

39. return c.cacheStorage.IndexKeys(indexName, indexKey)

40. }

41. func (c *cache) ListIndexFuncValues(indexName string) []string {

42. return c.cacheStorage.ListIndexFuncValues(indexName)

43. }

44. func (c *cache) ByIndex(indexName, indexKey string) ([]interface{}, error) {

45. return c.cacheStorage.ByIndex(indexName, indexKey)

46. }

47. func (c *cache) AddIndexers(newIndexers Indexers) error {

48. return c.cacheStorage.AddIndexers(newIndexers)

49. }

50. func (c *cache) Get(obj interface{}) (item interface{}, exists bool, err error) {

51. key, err := c.keyFunc(obj)

52. if err != nil {

53. return nil, false, KeyError{obj, err}

54. }

55. return c.GetByKey(key)

56. }

57. func (c *cache) GetByKey(key string) (item interface{}, exists bool, err error) {

58. item, exists = c.cacheStorage.Get(key)

59. return item, exists, nil

60. }

61. func (c *cache) Replace(list []interface{}, resourceVersion string) error {

62. items := map[string]interface{}{}

63. for _, item := range list {

64. key, err := c.keyFunc(item)

65. if err != nil {

66. return KeyError{item, err}

67. }

68. items[key] = item

69. }

70. c.cacheStorage.Replace(items, resourceVersion)

71. return nil

72. }

73. func (c *cache) Resync() error {

74. return c.cacheStorage.Resync()

75. }

kubernetes中主要的索引函式

我搜遍了kubernetes程式碼，發現最主要的索引的函式大概就下面幾種：

1. MetaNamespaceIndexFunc，定義在client-go/tools/cache/index.go中，從名字看就是獲取物件元資料的namesapce欄位，也就是所有物件以namespace作為索引鍵，這個就很好理解了；
2. indexByPodNodeName，定義在kubernetes/pkg/controller/daemon/deamon_controller.go，該索引函式計算的是Pod物件所在節點的名字；

為了方便理解，我們可以假設kubernetes主要就是一種索引函式（MetaNamespaceIndexFunc），也就是在索引中大部分就一個分類，這個分類的索引鍵就是namesapce。那麼有人肯定會問，如果這樣的話，所有的物件都存在一個namesapce索引鍵下面，這樣的效率豈不是太低了?其實client-go為每類物件都建立了Informer(Informer內有Indexer)，所以即便儲存在相同namesapce下的物件都是同一類，這個問題自然也就沒有了，詳情可以看我針對Informer寫的文章。

大家一定要區分MetaNamespaceIndexFunc和MetaNamespaceKeyFunc的區分，第一個索引鍵計算函式，第二個是物件鍵計算函式，第一個返回的是namespace，第二個返回的是物件包含namespace在內的物件全程。

總結

如果讀者還對所謂的索引、索引分類、索引鍵、物件鍵比較混亂的話，我就要拿出我更加大白話的總結了：所有的物件(Pod、Node、Service等等)都是有屬性/標籤的，如果屬性/標籤就是索引鍵，Indexer就會把相同屬性/標籤的所有物件放在一個集合中，如果在對屬性/標籤分一下類，也就就是我們本文的將的Indexer的核心內容了。甚至你可以簡單的理解為Indexer就是簡單的把相同namesapce物件放在一個集合中，kubernetes就是基於屬相/標籤檢索的，這麼理解也不偏頗，方法不重要，只要能幫助理解都是好方法。

有人肯定會說你早說不就完了麼？其實如果沒有上面的分析，直接給出總結是不是顯得我很沒水平？關鍵是讀者理解的也不會深刻！

原文轉載於：https://blog.csdn.net/weixin_42663840/article/details/81530606