Kubernetes 控制器入門:調和迴圈怎麼運作?

在後端架構與微服務的日常維運中,你可能早已習慣在 Kubernetes 部署清單寫下 replicas: 3,並發現即使手動刪除 Pod,系統也會自動重新建立、把副本補滿。但這套「自我修復」的神奇能力究竟從何而來?

在控制平面(Control Plane)深處,kube-controller-manager(以下簡稱 KCM)默默打包了數十個核心控制器。這篇文章寫給具備後端開發經驗、正在入門 DevOps 與 Kubernetes,但尚未深入學習 Go 語言的工程師。

我們將循序拆解四個關鍵問題:控制器到底在解決什麼問題?KCM 在控制平面的定位是什麼?一個事件從產生到狀態收斂,會經過哪五個內部站點?以及——「控制器本質上是一條 goroutine」這句話,究竟哪裡對、哪裡不對。


一、控制器解決什麼問題:宣告式 API 與調和迴圈

要理解控制器,必須先回到命令式思維與宣告式架構的根本分歧。

傳統維運腳本多半採「命令式」(Imperative):你編寫指令要求系統「建立三台虛擬機器、安裝應用程式、掛載負載平衡器」。腳本執行完畢後即刻退場,但真實環境隨時會發生狀態漂移(State Drift)——節點當機、網路不穩、人為誤改設定或磁碟寫滿。退場的腳本不會感知到這些變化,更無法主動復原。

Kubernetes 採取了「宣告式」(Declarative)架構:使用者不描述執行步驟,而是宣告期望達成的最終結果。當你把一份 YAML 送交 API Server,期望狀態便被持久化儲存在 etcd(Kubernetes 用來保存整個叢集狀態的分散式資料庫)中,並反映在 API 物件的 spec 欄位。

將實際世界持續拉回期望狀態的重責大任,便由 控制器(Controller)承擔。控制器在概念上是一個永不停止的無窮迴圈:

 for {
   desired := 讀取期望狀態()
   // spec:使用者宣告「需要三個副本」
   actual  := 觀察實際狀態()
   // 叢集目前的實際運作狀況
   diff    := 計算差異(desired, actual)
   if diff 不為空 {
     執行動作,讓 actual 靠近 desired
     // 這一步稱為調和(Reconcile)
   }
   等待下一輪(監聽到新事件,或定時逾時重跑)
 }

這個運作模式稱為調和迴圈(Reconcile Loop)或控制迴圈(Control Loop)。Kubernetes 名字源自希臘語中的「舵手」(κυβερνήτης),並與控制理論經典《控制論》(Cybernetics)共享同一個希臘字根,理念也相通:設定目標值,系統透過持續回饋與調整來消除偏差。

 +---------------------------------------------------------+
 | Reconcile Loop                                          |
 |                                                         |
 | +-------------+      Read Spec      +---------------+   |
 | | Desired     |<--------------------| API Server    |   |
 | | State       |                     | (etcd)        |   |
 | +-------------+                     +---------------+   |
 |        |                                    ^           |
 |        v Compare                            | Update    |
 | +-------------+     Drive Action            | Status    |
 | | Calculate   |-----------------------------+           |
 | | Difference  |                                         |
 | +-------------+                                         |
 |        ^                                                |
 |        | Observe Actual                                 |
 | +-------------+                                         |
 | | Actual      |                                         |
 | | State       |                                         |
 | +-------------+                                         |
 +---------------------------------------------------------+

水平觸發:以「目前狀態」為真相來源

對於有網路或系統程式設計經驗的工程師而言,這裡存在一個關鍵對照:水平觸發(Level-triggered)與邊緣觸發(Edge-triggered)。

在事件驅動架構中:

Kubernetes 控制器採用水平觸發的設計原則。在分散式環境中,網路連線可能中斷、控制器可能重啟、管理員可能手動介入。若將邏輯綁定在單一事件上,系統將相當脆弱。

因此,控制器透過兩套機制協同達成可靠性:

  1. 即時長連線感知(Watch):透過 HTTP 長連線即時接收資源異動,將其作為「叫醒鈴」觸發調和。
  2. 週期性重新同步(Resync):定期走訪本地記憶體快取中的所有物件,主動觸發重新比對。

即使某次事件通知因網路不穩而遺失,下一輪調和依然會比對最新狀態並補齊動作。例如手動刪除一個受管轄的 Pod,底層控制器並非靠「收到刪除事件」才去重建,而是在調和時發現「期望 3 個、實際只有 2 個」,狀態差異本身就是觸發重建動作的直接依據。

冪等性與最終一致性

調和迴圈具備兩大核心工程特質:

這套架構也具體體現於 spec 與 status 的職責劃分。在多數 Kubernetes API 資源物件中:

兩者都集中儲存於 API Server,期望與現實的差距就攤在物件上、隨時可以查證,控制器本身完全不必維護任何持久狀態。


二、kube-controller-manager 的定位:誰在跑哪些控制器

在 Kubernetes 控制平面中,各核心元件的職責分工非常明確:

元件名稱運作型態核心職責
kube-apiserver常駐服務唯一直接讀寫 etcd 的入口,所有元件彼此溝通的樞紐
etcd分散式儲存儲存整個叢集所有狀態的唯一真相來源
kube-scheduler獨立二進位檔專職「決策」:為未綁定節點的 Pod 挑選最佳節點
kube-controller-manager獨立二進位檔將數十個內建核心控制器打包在單一行程中運作
cloud-controller-manager獨立二進位檔負責與各大雲端供應商 API 互動的專屬控制器
 +--------------------------------------------------------+
 | Kubernetes Control Plane                               |
 |                                                        |
 |  +---------------------+    +---------------------+    |
 |  | kube-scheduler      |    | KCM / CCM           |    |
 |  | (Placement)         |    | (Reconcile Loops)   |    |
 |  +---------------------+    +---------------------+    |
 |             |                          |               |
 |             |      Watch / Update      |               |
 |             v                          v               |
 |  +------------------------------------------------+    |
 |  |                 kube-apiserver                 |    |
 |  +------------------------------------------------+    |
 |                          |                             |
 |                          v                             |
 |  +------------------------------------------------+    |
 |  |                      etcd                      |    |
 |  +------------------------------------------------+    |
 +--------------------------------------------------------+

數十個控制器合一:單一行程的工程取捨

KCM 將 Deployment、ReplicaSet、StatefulSet、DaemonSet、Job、CronJob、Node Lifecycle、Pod GC、Namespace、ServiceAccount、ResourceQuota 等數十個控制器全部編譯並打包進單一二進位檔案、單一作業系統行程中。

在原始碼層次,KCM 透過集中註冊表(NewControllerDescriptors)管理所有控制器清單。KCM 啟動時逐一走訪註冊表建立實例,並啟動各控制器的 Run 調和方法。

將數十個控制器塞進同一個行程,是刻意的架構取捨:

為了防範權限過大,KCM 支援 --use-service-account-credentials 參數,讓每個內部控制器使用獨立的 ServiceAccount 憑證呼叫 API Server,遵循最小權限原則。

為什麼其他元件不放進 KCM?

高可用性(HA)與 Leader Election

當控制平面部署多個節點以實現高可用性(HA)時,若多個節點上的 KCM 同時調和同一個資源,勢必會產生嚴重的競爭條件與狀態覆蓋。

因此,控制平面多實例必須採用主備模式(Active-Standby),透過領導者選舉(--leader-elect=true)確保同一時間只有單一 Active 實例在執行調和。

 Node 1 (Leader)          Node 2, 3 (Standby)
 +------------------+     +------------------+
 | KCM Process      |     | KCM Process      |
 | [Active Workers] |     | [Standby Mode]   |
 +------------------+     +------------------+
          |                        |
          | Heartbeat Renew        | Watch Lease
          v                        v
 +-------------------------------------------+
 | Lease: kube-controller-manager            |
 | Namespace: kube-system                    |
 +-------------------------------------------+

所有 KCM 實例會共同競爭 coordination.k8s.io API 群組下的 Lease 資源物件(位於 kube-system 命名空間)。


三、一個控制器的內部:以 Deployment 控制器走完整流程

了解全域架構後,我們聚焦拆解單一控制器的內部構造。以最常見的 Deployment Controller 為例分析。

前置心智模型:分層收斂架構(Layering)

理解控制器的關鍵在於分層收斂。當你在終端機執行 kubectl get deploy,rs,pod 時,看到的其實是三個階層的協同運作:

  1. Deployment Controller只負責管理 ReplicaSet 的版本與數量
  2. ReplicaSet Controller只負責確保 Pod 副本數符合指定數值
  3. Kubelet (Node Agent)只負責在本機節點啟動與維持容器執行

請特別注意:Deployment Controller 本身不直接建立或刪除 Pod。它只負責調控底層的 ReplicaSet;由 ReplicaSet Controller 負責維持 Pod 的副本數量;最後由各節點上的 kubelet 負責在該節點執行容器。

每一層控制器僅對其直接下層物件的「狀態」負責,層與層之間沒有任何直接 RPC 呼叫,完全透過 API Server 的物件宣告進行解耦。這正是 Kubernetes 能夠平滑完成零停機滾動更新的基礎。

五站內部管線

整個控制器的內部處理鏈條由五大站點組成:

 Deployment Controller Pipeline:
 [ API Server ]
   |
   | LIST / WATCH
   v
 [ Reflector ]
   |
   | handleDeltas
   v
 [ Delta Queue (RealFIFO) ]
   |
   v
 [ SharedInformer ]
   |
   +--> Update Memory Cache --> [ Local Indexer Cache ]
   |
   +--> OnAdd / Update --> [ ResourceEventHandler ]
                             |
                             | Extract Key (ns/name)
                             v
                           [ WorkQueue (RateLimit) ]
                             |
                             | Pop Key
                             v
                           [ Worker Pool (1..N) ]
                             |
                             | syncDeployment
                             | Read Cache (Lister)
                             v
                           [ Local Indexer Cache ]

第一站:Reflector(LIST + WATCH)

控制器需要精準獲知世界現況。位於 Kubernetes 官方 Go 客戶端函式庫(client-go)中的 Reflector,運作在一條專屬的 goroutine(Go 語言的輕量執行單位,第四章會進一步說明)上:

  1. 取得資源的完整初始快照。新版 client-go(v1.35 起)預設改用帶 initial events 的串流 WATCH(watch-list),LIST 退為不支援時的備援路徑。
  2. 接著維持 HTTP WATCH 長連線,持續接收後續的新增與變更。
  3. 若連線中斷,Reflector 會透過指數退避自動重連,必要時重新取得完整快照,確保資料毫無遺漏。

每個收到的變更事件被封裝為帶有類型(Added / Updated / Deleted)的 Delta 物件,推入 Delta 佇列。新版 client-go(v1.33 起)預設為逐事件傳遞、不做同 Key 折疊的 RealFIFO;會合併同 Key 事件的 DeltaFIFO,則是 v1.33 之前的舊版實作。

第二站:SharedInformer(消費 Delta、更新快取與事件派發)

SharedInformer 由另一條 goroutine 驅動,持續從 Delta 佇列取出 Delta:

  1. 更新本地快取(Indexer):將最新物件寫入記憶體快取。後續所有調和讀取都直接查詢此快取,不再傳送網路請求給 API Server。
  2. 事件派發:將事件派發給所有向該 Informer 註冊的事件處理器(Event Handler)。
  3. 週期性 Resync:依設定間隔主動通知處理器重新掃描快取中的物件,作為水平觸發設計的保險——即使事件遺漏,時間一到仍會重新比對一遍。

顧名思義,SharedInformer 的「Shared(共享)」是指:同一資源(如 Pod)的 Watch 連線與記憶體快取,可供 KCM 內多個控制器共用,避免連線暴增。

第三站:Event Handler(關聯反查與提取 Key)

Deployment Controller 在初始化時(NewDeploymentController),會向 Deployment、ReplicaSet 與 Pod 的 Informer 註冊事件處理器。

這些 Event Handler 不執行具體的商業邏輯,僅執行「提取 Key 與關聯反查」:

這相當於打上標記:「這個 Deployment 底下的世界變了,待會請重新計算」。

第四站:WorkQueue(去重、限流與防雪崩)

client-go 的 WorkQueue 不是一般的先進先出佇列,它內建了關鍵防護機制:

第五站:Worker Pool(執行 Reconcile)

當控制器啟動時,Run 方法會先透過 WaitForNamedCacheSync 等待所有 Informer 完成本地快取的首次完整同步(確保快取已就緒),隨後啟動多條 worker goroutine(預設 5 條)。

每條 worker 獨立循環執行 processNextWorkItem:

  1. 從 WorkQueue 取出一個 Key。
  2. 呼叫 syncHandler(即 syncDeployment)執行核心調和邏輯。
  3. 透過本地快取讀取介面(Lister)取得 Deployment 期望值,並根據 Owner Reference 找出其名下的所有 ReplicaSet。
  4. 比對新舊 ReplicaSet 的副本數,按照滾動更新策略調配兩者比例、建立或縮減 ReplicaSet,並將就緒狀態回寫至 API Server。
  5. 若執行失敗,在重試上限內重新加入限流佇列等待下一輪處理。

四、「控制器 = goroutine」?——修正這句話

社群中常有一種簡化說法:「KCM 管理所有控制器,而控制器本質上就是 Go 的 goroutine」。這句話究竟準不準確?

對的一半:行程內的啟動機制

這句話對的地方在於:KCM 確實將內建控制器編譯在同一個二進位檔案中,且在 KCM 啟動流程中,每一個控制器的 Run 方法確實是由一條獨立的 goroutine 所啟動(go func() { ... controller.Run(ctx) }())。

你可以把 Go 語言的 goroutine 想成輕量執行緒:起始記憶體堆疊(Stack)僅約 2 KB,由 Go runtime 在使用者空間負責排程,把大量 goroutine 映射到少數幾條作業系統核心執行緒上。這讓單一程式能夠輕鬆維持數萬條獨立運作的迴圈,為控制器提供了絕佳的並行執行環境。

不對的一半:數量面向與本質面向

這句話存在兩個層次的嚴重偏差:

1. 數量面向的低估

單一控制器內部絕非只有一條 goroutine。

將 KCM 內數十個控制器及其背後的 Informer 與 Worker 池加總,一個處於 Leader 狀態的 KCM 行程內部,通常同時跑著數百條協同分工的 goroutine。

2. 本質面向的混淆

更重要的是:控制器是一種軟體架構模式,而不是特定語言的執行單位。

脫離 Go 語言的語境,控制器的本質是: 控制器 = Informer(觀察世界)+ Local Cache(本地快取)+ WorkQueue(去重限流)+ Reconcile Function(冪等收斂)

這套模式完全獨立於程式語言:

goroutine 只是 Go 語言在實作此架構模式時所採用的執行載體,迴圈與狀態收斂才是控制器的架構靈魂。

 +--------------------------------------------------+
 | Architecture Hierarchy                           |
 |                                                  |
 | 1. OS Process : kube-controller-manager          |
 |    (Monolithic Binary)                           |
 |         |                                        |
 | 2. Architectural Pattern : Controllers           |
 |    (Informer + WorkQueue + Reconcile)            |
 |         |                                        |
 | 3. Execution Vehicle : goroutines                |
 |    (Reflectors, Informers, Workers)              |
 +--------------------------------------------------+

結語

總結這篇文章的核心脈絡,可以用三句話概括:

  1. 控制器的核心是調和迴圈:透過水平觸發與冪等性比對 spec 與 status,以最終一致性消除系統狀態漂移。
  2. KCM 是控制器的整合總管:將數十個控制器封裝於單一行程共用快取,並透過 Lease 機制選出唯一的 Active Leader。
  3. goroutine 是載體,迴圈才是本質:單一控制器由多條 goroutine 協同驅動(Reflector、Informer、WorkQueue 與 Worker Pool),控制器是架構模式,而非單純的執行緒。

如果你想親自動手驗證與實踐,可以嘗試以下指令與延伸路徑:

# 查看誰持有 KCM 的 Lease 領導者租約
kubectl -n kube-system get lease kube-controller-manager -o yaml

# 觀察同一個應用的三層物件階層(Deployment -> RS -> Pod)
kubectl get deploy,rs,pod -l app=myapp

# 查詢 KCM 匯出的 WorkQueue 運作指標(佇列深度、延遲)
kubectl get --raw /metrics | grep workqueue

想進一步深入實作,推薦閱讀官方的 sample-controller 或使用 Kubebuilder 親手建立自訂資源定義(CRD)控制器,實際體會 Reconcile() 函式的設計邊界;亦可直接研讀 Kubernetes 原始碼庫中的 pkg/controller/deployment/deployment_controller.go,探索各元件如何精準協作。


參考資料