Kubelet-1 Kubelet 会做些什么

// k8s.io\kubernetes\pkg\kubelet\kubelet.go
func (kl *Kubelet) Run(updates <-chan kubetypes.PodUpdate) {}
	kl.initializeModules()
		// Prometheus metrics.
		metrics.Register(
			kl.runtimeCache,
			collectors.NewVolumeStatsCollector(kl),
			collectors.NewLogMetricsCollector(kl.StatsProvider.ListPodStats),
		)
		metrics.SetNodeName(kl.nodeName)
		// TODO: 1.!!! 
		// Start async garbage collection of images.
		kl.imageManager.Start()

		// TODO: 2.!!!!!! 
		// Watches cadvisor for system oom's and records an event for every system oom encountered.
		kl.oomWatcher.Start(kl.nodeRef)

		kl.resourceAnalyzer.Start()
			// updateCachedPodVolumeStats calculates and caches the PodVolumeStats for every Pod known to the kubelet.
			go wait.Forever(func() { s.updateCachedPodVolumeStats() }, s.calcPeriod)

	// TODO: 3.!!!!!
	// VolumeManager runs a set of asynchronous loops that figure out which
	// volumes need to be attached/mounted/unmounted/detached based on the pods
	// scheduled on this node and makes it so.
	go kl.volumeManager.Run(kl.sourcesReady, wait.NeverStop)

		// DesiredStateOfWorldPopulator periodically loops through the list of active
		// pods and ensures that each one exists in the desired state of the world cache
		// if it has volumes. It also verifies that the pods in the desired state of the
		// world cache still exist, if not, it removes them.
		go vm.desiredStateOfWorldPopulator.Run(sourcesReady, stopCh)

		// Reconciler runs a periodic loop to reconcile the desired state of the world
		// with the actual state of the world by triggering attach, detach, mount, and
		// unmount operations.
		go vm.reconciler.Run(stopCh)

	// TODO:important. 4.!!!!!!!!!! 
	// Start syncing node status immediately, this may set up things the runtime needs to run.
	go wait.Until(kl.syncNodeStatus, kl.nodeStatusUpdateFrequency, wait.NeverStop)
		// syncNodeStatus should be called periodically from a goroutine.
		// It synchronizes node status to master if there is any change or enough time
		// passed from the last sync, registering the kubelet first if necessary.
		func (kl *Kubelet) syncNodeStatus() {}
			kl.registerWithAPIServer()
			// updateNodeStatus updates node status to master with retries if there is any
			// change or enough time passed from the last sync.
			kl.updateNodeStatus()
				// In large clusters, GET and PUT operations on Node objects coming
				// from here are the majority of load on apiserver and etcd.
				// To reduce the load on etcd, we are serving GET operations from
				// apiserver cache (the data might be slightly delayed but it doesn't
				// seem to cause more conflict - the delays are pretty small).
				// If it result in a conflict, all retries are served directly from etcd.
				tryUpdateNodeStatus()
	// fastStatusUpdateOnce starts a loop that checks the internal node indexer cache for when a CIDR
	// is applied  and tries to update pod CIDR immediately. After pod CIDR is updated it fires off
	// a runtime update and a node status update. Function returns after one successful node status update.
	// Function is executed only during Kubelet start which improves latency to ready node by updating
	// pod CIDR, runtime status and node statuses ASAP.
	go kl.fastStatusUpdateOnce()
		// ....................
		// 不断尝试更新 CIDR，成功后，直接调用 syncNodeStatus() 更新 node 状态.
		if node.Spec.PodCIDR != "" {
			if _, err := kl.updatePodCIDR(node.Spec.PodCIDR); err != nil {
				klog.Errorf("Pod CIDR update failed %v", err)
				continue
			}
			kl.updateRuntimeUp()
			kl.syncNodeStatus()
			return
		}

	// start syncing lease
	// create or update lease periodically
	if utilfeature.DefaultFeatureGate.Enabled(features.NodeLease) {
		go kl.nodeLeaseController.Run(wait.NeverStop)
	}

	// TODO:important. 5.!!!!!!!!! 
	// updateRuntimeUp calls the container runtime status callback, 
	// initializing the runtime dependent modules when the container runtime first comes up,
	// and returns an error if the status check fails.  If the status check is OK,
	// update the container runtime uptime in the kubelet runtimeState.
	go wait.Until(kl.updateRuntimeUp, 5*time.Second, wait.NeverStop)
		func (kl *Kubelet) updateRuntimeUp() {}
			kl.containerRuntime.Status()
			initializeRuntimeDependentModules() {}
				kl.cadvisor.Start()
				// get nodeinfo or initilized.
				kl.getNodeAnyWay()
				// 
				kl.containerManager.Start(node, kl.GetActivePods, kl.sourcesReady, kl.statusManager, kl.runtimeService)
					cm.cpuManager.Start(cpumanager.ActivePodsFunc(activePods), podStatusProvider, runtimeService)
					cm.setupNode(activePods)
					// Start starts the Device Plugin Manager and start initialization of
					// podDevices and allocatedDevices information from checkpointed state and
					// starts device plugin registration service.
					cm.deviceManager.Start(devicemanager.ActivePodsFunc(activePods), sourcesReady)
					// TODO: important. 6 !!!!!! 
					// Start starts the control loop to observe and response to low compute resources.
					kl.evictionManager.Start(kl.StatsProvider, kl.GetActivePods, kl.podResourcesAreReclaimed, evictionMonitoringPeriod)
				// Needed to observe and respond to situations that could impact node stability
				kl.containerLogManager.Start()
				if kl.enablePluginsWatcher {
					// Adding Registration Callback function for CSI Driver
					kl.pluginWatcher.AddHandler(pluginwatcherapi.CSIPlugin, pluginwatcher.PluginHandler(csi.PluginHandler))
					// Adding Registration Callback function for Device Manager
					kl.pluginWatcher.AddHandler(pluginwatcherapi.DevicePlugin, kl.containerManager.GetPluginRegistrationHandler())
					// Start the plugin watcher
					klog.V(4).Infof("starting watcher")
					err := kl.pluginWatcher.Start()


	// Start loop to sync iptables util rules
	if kl.makeIPTablesUtilChains {
		// syncNetworkUtil ensures the network utility are present on host.
		// Network util includes:
		// 1. 	In nat table, KUBE-MARK-DROP rule to mark connections for dropping
		// 	Marked connection will be drop on INPUT/OUTPUT Chain in filter table
		// 2. 	In nat table, KUBE-MARK-MASQ rule to mark connections for SNAT
		// 	Marked connection will get SNAT on POSTROUTING Chain in nat table
		go wait.Until(kl.syncNetworkUtil, 1*time.Minute, wait.NeverStop)
	}

	// podKiller launches a goroutine to kill a pod received from the channel if
	// another goroutine isn't already in action.
	go wait.Until(kl.podKiller, 1*time.Second, wait.NeverStop)

	// Syncs pods statuses with apiserver; also used as a cache of statuses.
	// case syncRequest := <-m.podStatusChannel: syncPod(syncRequest)
	// case <-syncTicker: m.syncBatch() 
	kl.statusManager.Start()

	// TODO: 7.!!!! 
	// pod probe
	kl.probeManager.Start()

	// ...
	go kl.runtimeClassManager.Run(wait.NeverStop)

	// TODO: 8.!!!!
	// Start the pod lifecycle event generator.
	kl.pleg.Start()
		// Get all the pods. 
		// g.runtime.GetPods(true)
		// kube
		// pods := kubecontainer.Pods(podList)
		// Compare the old and the current pods, and generate events.
		// computeEvents
		// If there are events associated with a pod, we should update the podCache.
		go wait.Until(g.relist, g.relistPeriod, wait.NeverStop)
			// relist queries the container runtime for list of pods/containers, compare
			// with the internal pods/containers, and generates events accordingly.
			func (g *GenericPLEG) relist() {}


	// TODO:important. 9.!!!!!!!
	// syncLoop is the main loop for processing changes. It watches for changes from
	// three channels (file, apiserver, and http) and creates a union of them. For
	// any new change seen, will run a sync against desired state and running state. If
	// no changes are seen to the configuration, will synchronize the last known desired
	// state every sync-frequency seconds. Never returns.
	kl.syncLoop(updates, kl)
		kl.syncLoopIteration(updates, handler, syncTicker.C, housekeepingTicker.C, plegCh)