k8s 源码分析 informer篇

之前介绍过informer的流程,文章在 informer介绍。今天梳理一下他的源码和流程。

请添加图片描述

一、概念

什么是 Informer
informer 是 client-go 中的核心工具包,informer 其实就是一个带有本地缓存和索引机制的,可以注册 EventHandler 的 client 本地缓存被称为 Store,索引被称为 Index 。使用 informer 的目的是为了减轻 apiserver 数据交互的压力而抽象出来的一个 cache 层,客户端对 apiserver 数据的 读取和监听操作都通过本地 informer进行。

为什么需要 Informer 机制

Kubernetes 各个组件都是通过 REST API 跟 API Server 交互通信的,而如果每次每一个组件都直接跟 API Server 交互去读取/写入到后端的etcd的话,会对 API Server 以及etcd造成非常大的负担。 而 Informer 机制是为了保证各个组件之间通信的实时性、可靠性,并且减缓对 API Server和etcd 的负担。

informer和configch(newSourceApiserverFromLW)区别
之前介绍过一篇configch的文章 configch源码。这篇文章主要是介绍newSourceApiserverFromLW方法,与kubelet交互后进行更新删除等。并且newSourceApiserverFromLW只监听一个api对象(pod)
而informer则监听整个namespace下的api对象。但是informer不会做出动作,只是监听后维护自己的缓存。方便用户去使用最新数据,避免每次都http访问api-server浪费资源

二、注册及接收

大概步骤如下

  • 启动informer
  • 注册processLoop和reflector
  • reflector开始LIST&WATCH。同时processLoop开始循环pop队列数据(步骤三)
  • watch到的数据进行对比处理,不存在的存入的queue队列中

注册
2.1.start注册
代码位置:vendor/k8s.io/client-go/informer/factory.go

func (f *sharedInformerFactory) Start(stopCh <-chan struct{}) {
	f.lock.Lock()
	defer f.lock.Unlock()
	if f.shuttingDown {
		return
	}
	for informerType, informer := range f.informers {
		if !f.startedInformers[informerType] {
			f.wg.Add(1)
			informer := informer
			go func() {
				defer f.wg.Done()
				//启动informer
				informer.Run(stopCh)
			}()
			f.startedInformers[informerType] = true
		}
	}
}

2.2 注册processLoop和reflector
代码位置:vendor/k8s.io/client-go/tools/cache/controller.go

//完成一些初始化,总要的是下面两个函数
    //启动监听
    wg.StartWithChannel(stopCh, r.Run)
    //这里是循环delta FIFO的queue,然后pop出来最新的
	wait.Until(c.processLoop, time.Second, stopCh)

2.3 reflector开始LIST&WATCH
代码位置:vendor/k8s.io/client-go/tools/cache/reflector.go
这里开始LIST&WATCH

	wait.BackoffUntil(func() {
		if err := r.ListAndWatch(stopCh); err != nil {
			r.watchErrorHandler(r, err)
		}
	}, r.backoffManager, true, stopCh)
   ....省略
   //开始watch
   return r.watch(w, stopCh, resyncerrc)
   ...省略
   //watch函数开始
   		err = watchHandler(start, w, r.store, r.expectedType, r.expectedGVK, r.name, r.typeDescription, r.setLastSyncResourceVersion, nil, r.clock, resyncerrc, stopCh)

2.4 watch处理数据
还是上面reflector文件,开始处理接收到的最新watch的信息

switch event.Type {
			case watch.Added:
				err := store.Add(event.Object)
				if err != nil {
					utilruntime.HandleError(fmt.Errorf("%s: unable to add watch event object (%#v) to store: %v", name, event.Object, err))
				}
			case watch.Modified:
				err := store.Update(event.Object)
				if err != nil {
					utilruntime.HandleError(fmt.Errorf("%s: unable to update watch event object (%#v) to store: %v", name, event.Object, err))
				}
			case watch.Deleted:
				err := store.Delete(event.Object)
				if err != nil {
					utilruntime.HandleError(fmt.Errorf("%s: unable to delete watch event object (%#v) from store: %v", name, event.Object, err))
				}
			case watch.Bookmark:
			
				if _, ok := meta.GetAnnotations()["k8s.io/initial-events-end"]; ok {
					if exitOnInitialEventsEndBookmark != nil {
						*exitOnInitialEventsEndBookmark = true
					}
				}
			default:
				utilruntime.HandleError(fmt.Errorf("%s: unable to understand watch event %#v", name, event))
			}

代码位置:vendor/k8s.io/client-go/tools/cache/delta_fifo.go
进入到更新。这里通过queueActionLocked函数验证验证一下obj是否存在,不存在则推倒queue队列中

func (f *DeltaFIFO) Update(obj interface{}) error {
	f.lock.Lock()
	defer f.lock.Unlock()
	f.populated = true
	return f.queueActionLocked(Updated, obj)
}
...省略部分代码
//queueActionLocked中就是获取到item映射出来的这个obj信息(items中存的数据和queue数据是一个。等到pop的时候这两个数据都会删掉),如果不存在则推送到queue中,如果存在则替换。
func (f *DeltaFIFO) queueActionLocked(actionType DeltaType, obj interface{}) error {
	id, err := f.KeyOf(obj)
	if err != nil {
		return KeyError{obj, err}
	}
	//根据id查到映射的api对象,然后推倒newDeltas中。如果是新的,则不进行对比,如果是老的(2个deltas)则进行去重。dedupDeltas里的逻辑就是如果是删除的话只保留一个,如果是添加则直接返回
	oldDeltas := f.items[id]
	newDeltas := append(oldDeltas, Delta{actionType, obj})
	newDeltas = dedupDeltas(newDeltas)
	//这里百分百会大于0,不会小于0
	if len(newDeltas) > 0 {
		if _, exists := f.items[id]; !exists {
			f.queue = append(f.queue, id)
		}
		f.items[id] = newDeltas
		//让wait的cond开始工作
		f.cond.Broadcast()
	} else {
		if oldDeltas == nil {
			klog.Errorf("Impossible dedupDeltas for id=%q: oldDeltas=%#+v, obj=%#+v; ignoring", id, oldDeltas, obj)
			return nil
		}
		klog.Errorf("Impossible dedupDeltas for id=%q: oldDeltas=%#+v, obj=%#+v; breaking invariant by storing empty Deltas", id, oldDeltas, obj)
		f.items[id] = newDeltas
		return fmt.Errorf("Impossible dedupDeltas for id=%q: oldDeltas=%#+v, obj=%#+v; broke DeltaFIFO invariant by storing empty Deltas", id, oldDeltas, obj)
	}
	return nil

到这里,接收的工作就完成了,已经将最新的数据推送到了queue中,下面就是开始处理这个queue了

三、弹出队列处理

  • 开启queue队列的循环接收
  • 获取到最新队列信息开始处理
  • 更新本地indexer缓存
  • 分发给监听informer的用户去触发回调函数
  • 如果用户定义的回调能够返回ErrRequeue类型错误,则会把这个资源信息重新推入到队列然后重新发送给用户

3.1 开始循环接收数据

func (c *controller) processLoop() {
	for {
	    //无限循环处理queue数据
		obj, err := c.config.Queue.Pop(PopProcessFunc(c.config.Process))
		}
}

3.2 这里面也是个for循环,如果队列大于0,则读取出来通过process处理,否则等待队列有新数据加入
代码位置 vendor/k8s.io/client-go/tools/cache/delta_fifo.go

for {
		for len(f.queue) == 0 {
			if f.closed {
				return nil, ErrFIFOClosed
			}
			f.cond.Wait()
		}
		id := f.queue[0]
		f.queue = f.queue[1:]
		depth := len(f.queue)
		//减少队列长度,四、replace中会介绍这个。这个等于0代表没有需要同步的了
		if f.initialPopulationCount > 0 {
			f.initialPopulationCount--
		}
		item, ok := f.items[id]
		delete(f.items, id)
		//进入这里
		err := process(item, isInInitialList)
		//如果用户定义的回调能够返回ErrRequeue类型错误,则会把这个资源信息重新推入到队列然后重新发送给用户
		if e, ok := err.(ErrRequeue); ok {
			f.addIfNotPresent(id, item)
			err = e.Err
		}
}

3.3 注册的回调。判断映射是否存在,存在的话则进行处理
代码位置 vendor/k8s.io/client-go/tools/cache/shared_informer.go

func (s *sharedIndexInformer) HandleDeltas(obj interface{}, isInInitialList bool) error {
	s.blockDeltas.Lock()
	defer s.blockDeltas.Unlock()

	if deltas, ok := obj.(Deltas); ok {
	    //如果映射存在,则进行处理
		return processDeltas(s, s.indexer, deltas, isInInitialList)
	}
	return errors.New("object given as Process argument is not Deltas")
}

3.4 处理本地缓存和回调
代码位置:vendor/k8s.io/client-go/tools/cache/controller.go

func processDeltas(
	handler ResourceEventHandler,
	clientState Store,
	deltas Deltas,
	isInInitialList bool,
) error {
	for _, d := range deltas {
		obj := d.Object

		switch d.Type {
		 //如果是添加、同步、替换、更新,则进入这里
		case Sync, Replaced, Added, Updated:
			if old, exists, err := clientState.Get(obj); err == nil && exists {
			    //更新indexer的本地缓存(步骤3.5)
				if err := clientState.Update(obj); err != nil {
					return err
				}
				//处理回调(步骤3.6)
				handler.OnUpdate(old, obj)
			} else {
				if err := clientState.Add(obj); err != nil {
					return err
				}
				handler.OnAdd(obj, isInInitialList)
			}
		case Deleted:
			if err := clientState.Delete(obj); err != nil {
				return err
			}
			handler.OnDelete(obj)
		}
	}
	return nil
}

3.5 更新本地indexer(Storage)缓存
代码位置:vendor/k8s.io/client-go/tools/cache/controller.go

func (c *cache) Update(obj interface{}) error {
	key, err := c.keyFunc(obj)
	if err != nil {
		return KeyError{obj, err}
	}
	c.cacheStorage.Update(key, obj)
	return nil
}

3.6处理回调

func (s *sharedIndexInformer) OnUpdate(old, new interface{}) {
	isSync := false
	if accessor, err := meta.Accessor(new); err == nil {
		if oldAccessor, err := meta.Accessor(old); err == nil {
			// Events that didn't change resourceVersion are treated as resync events
			// and only propagated to listeners that requested resync
			isSync = accessor.GetResourceVersion() == oldAccessor.GetResourceVersion()
		}
	}
	s.cacheMutationDetector.AddObject(new)
	//这个是重点,分发给监听者
	s.processor.distribute(updateNotification{oldObj: old, newObj: new}, isSync)
}

3.7 分发给监听者

func (p *sharedProcessor) distribute(obj interface{}, sync bool) {
	p.listenersLock.RLock()
	defer p.listenersLock.RUnlock()
    //p.listeners代表有几个监听者。这里循环所有监听者,把最新信息发送给监听者。
	for listener, isSyncing := range p.listeners {
		switch {
		case !sync:
			listener.add(obj)
		case isSyncing:		
			listener.add(obj)
		default:
			
		}
	}
}

到这里就处理结束了。如果想要使用监听者,需要用户自己建立informer进行监听。然后添加注册函数,就可以接收了

四、replace和resync

replace是用来操作来更新缓存中的对象,以确保对象完全更新,而不仅仅是部分更新。在第一次运行时会启动
resync是每隔 10 分钟进行一次重新同步操作,即调用 List 方法从 API Server 中拉取完整的资源列表。

4.1 replace

  • 先生成一个set集合用来存放数据
  • 遍历LIST传过来的所有list数据并生成key,同时添加到set集合中
  • 对队列中的对象做删除检测。这里是避免在与apiserver断开连接时错过了删除信息的意外而重新检测
  • 如果有本地缓存库,则进行与本地缓存的比对,如果本地缓存有数据,但是list没有,则删除这个数据
  • initialPopulationCount计算一下总量和有问题需要删除的总量(这里是为了以后判断是否sync成功)
func (f *DeltaFIFO) Replace(list []interface{}, _ string) error {
	f.lock.Lock()
	defer f.lock.Unlock()
	//先生成一个set集合用来存放数据
	keys := make(sets.String, len(list))
	action := Sync
	if f.emitDeltaTypeReplaced {
		action = Replaced
	}
	for _, item := range list {
		key, err := f.KeyOf(item)
		if err != nil {
			return KeyError{item, err}
		}
		keys.Insert(key)
		if err := f.queueActionLocked(action, item); err != nil {
			return fmt.Errorf("couldn't enqueue object: %v", err)
		}
	}
    //对队列中的对象做删除检测。这里是避免在与apiserver断开连接时错过了删除信息的意外而重新检测
	queuedDeletions := 0
	for k, oldItem := range f.items {
		if keys.Has(k) {
			continue
		}
		if n := oldItem.Newest(); n != nil {
			deletedObj = n.Object
			if d, ok := deletedObj.(DeletedFinalStateUnknown); ok {
				deletedObj = d.Obj
			}
		}
		queuedDeletions++
		if err := f.queueActionLocked(Deleted, DeletedFinalStateUnknown{k, deletedObj}); err != nil {
			return err
		}
	}
	if f.knownObjects != nil {
	    //如果有本地缓存库,则进行与本地缓存的比对,如果本地缓存有数据,但是list没有,则删除这个数据
		knownKeys := f.knownObjects.ListKeys()
		for _, k := range knownKeys {
			if keys.Has(k) {
				continue
			}
			if len(f.items[k]) > 0 {
				continue
			}
			deletedObj, exists, err := f.knownObjects.GetByKey(k)
			if err != nil {
				deletedObj = nil
			} else if !exists {
				deletedObj = nil
			}
			queuedDeletions++
			if err := f.queueActionLocked(Deleted, DeletedFinalStateUnknown{k, deletedObj}); err != nil {
				return err
			}
		}
	}
	if !f.populated {
		f.populated = true
		f.initialPopulationCount = keys.Len() + queuedDeletions
	}
	return nil
}

4.2 resync
默认每10分钟同步一次。这个时间间隔可以通过 ResyncPeriodFunc 函数进行调整

  • 遍历所有数据
  • 如果这个数据在items映射里存在,则不管这个信息(因为如果items中存在,则代表是api-server发过来的最新的还没处理,这里需要跳过而不是覆盖)
  • 如果不是则同步这个数据。其实就是把本地缓存库的数据再次放入队列中,重新消费做一次update的动作
func (f *DeltaFIFO) Resync() error {
	f.lock.Lock()
	defer f.lock.Unlock()

	if f.knownObjects == nil {
		return nil
	}
    //获得所有缓存库数据
	keys := f.knownObjects.ListKeys()
	for _, k := range keys {
	    //遍历所有数据去验证
		if err := f.syncKeyLocked(k); err != nil {
			return err
		}
	}
	return nil
}


func (f *DeltaFIFO) syncKeyLocked(key string) error {
	obj, exists, err := f.knownObjects.GetByKey(key)
	if err != nil {
		klog.Errorf("Unexpected error %v during lookup of key %v, unable to queue object for sync", err, key)
		return nil
	} else if !exists {
		klog.Infof("Key %v does not exist in known objects store, unable to queue object for sync", key)
		return nil
	}
	//获得这个数据的id
	id, err := f.KeyOf(obj)
	if err != nil {
		return KeyError{obj, err}
	}
	//如果这个数据在items映射里存在,则不管这个信息(因为如果items中存在,则代表是api-server发过来的最新的还没处理,这里需要跳过而不是覆盖)
	if len(f.items[id]) > 0 {
		return nil
	}
	//如果不是则同步这个数据。其实就是把本地缓存库的数据再次放入队列中,重新消费做一次update的动作
	if err := f.queueActionLocked(Sync, obj); err != nil {
		return fmt.Errorf("couldn't queue object: %v", err)
	}
	return nil
}

对于重新把本地缓存库的数据再次放入队列中,重新消费做一次update的动作可能有些疑问,这里举个例子。
如果本地缓存中a=1,然后出发了用户的add操作。但是用户有一些一次性的特殊情况需要处理把a=1改成了a=2。等过了10分钟resync同步了,这时候就会把a=1再次推到用户的add操作,用户就可以继续使用a=1了
但是大部分情况是为了用户端的回调失败或未执行时,确保再次触发统一操作。

  • 1
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值