K8s 架構白話:Kubernetes 控制平面、節點、Pod 怎麼分工

K8s 架構分成兩半:控制平面負責做決定(記帳、派工、盯進度),節點負責把容器跑起來,Pod 是被派到節點上的最小工作單位。

這篇不只畫架構圖。我們在免費的 Cloud Shell 用 Minikube 開一個真的 Kubernetes 叢集,把控制平面的 7 個系統 Pod 一個一個點名,再做一個網路教學很少做的實驗:把負責派工的排程器拿掉,看看新的 Pod 會怎樣。結果是:舊的網站照跑,新的 2 個 Pod 全部卡在 Pending,把排程器放回去之後才排進節點。

這是「容器系列」的第 9 篇,也是 Kubernetes 段落的第一篇。全部在 Cloud Shell 實際跑過,輸出都是真實結果(2026 年 11 月實測,Minikube v1.38.1、Kubernetes v1.35.1)。如果你還不確定自己需不需要 Kubernetes,可以先看Kubernetes 是什麼?白話解釋+判斷你是否真的需要它,那篇講「要不要用」,這篇講「裡面怎麼分工」。

K8s 架構一張圖:左邊控制平面有 kube-apiserver、etcd、kube-scheduler、controller-manager,右邊節點有 kubelet、容器執行環境、kube-proxy 和 Pod

為什麼你需要知道

  • 排錯時才知道要找誰:Pod 卡在 Pending 通常是排程器找不到節點;卡在 ImagePullBackOff 是節點上的 kubelet 拉不到映像檔。知道誰負責哪一段,才不會亂槍打鳥
  • 面試幾乎一定問:「你下 kubectl apply 之後,叢集裡發生了什麼事?」這題答得出來,面試官就知道你不是只會背指令
  • 證照的大比重:Kubernetes 管理員證照 CKA 的考試範圍裡,「叢集架構、安裝與設定」佔 25%、「排錯」佔 30%(2026 年 11 月查 Linux Foundation 官方頁),兩塊都要懂架構
  • 用雲端服務時才知道自己付錢買了什麼:Google 的 GKE 幫你管控制平面,你在叢集裡看不到 kube-apiserver;不懂架構,就不知道每小時 0.10 美元的叢集管理費到底在付什麼

先把三個大名詞講清楚

Kubernetes(K8s)是什麼

Kubernetes 是一套幫你管理很多容器的系統:你告訴它「我要 3 個網站容器」,它負責挑機器放、壞了重開、流量變大時加開。

  • 比喻:Docker 是一個廚師會做菜;Kubernetes 是整間餐廳的管理制度,決定哪個廚師做哪張單、誰請假了誰補上
  • 來龍去脈:Kubernetes 是希臘文的「舵手」,K8s 是因為 K 和 s 中間有 8 個字母。Google 在 2014 年把它開源,裡面放了 Google 內部跑大量服務十幾年的經驗(Kubernetes 官方介紹)
  • 為什麼要學:容器一多,手動 docker run 管不過來;GKE、EKS、AKS 這些雲端服務底下都是 Kubernetes

想先了解容器本身,可以看第 1 篇:Docker 入門教學。

叢集(Cluster)是什麼

叢集是一群被 Kubernetes 統一管理的機器,對你來說它像一台很大的電腦。

  • 比喻:一間餐廳,有外場辦公室,也有好幾個廚房工作檯
  • 來龍去脈:英文 cluster 是「一串、一群」,像一串葡萄。一台機器會壞、會不夠用,所以把很多台綁在一起,壞一台還有別台
  • 為什麼要學:GKE 計費、權限、網路設定都以「叢集」為單位

節點(Node)是什麼

節點是叢集裡的一台機器,可以是實體主機,也可以是雲端的虛擬機器(Virtual Machine,用軟體切出來的一台電腦)。

  • 比喻:餐廳裡的一個廚房工作檯
  • 來龍去脈:node 原本是網路圖上「一個點」的意思,叢集畫成圖時,每台機器就是一個點
  • 為什麼要學:Pod 最後一定要落在某個節點上跑;節點不夠力,Pod 就排不進去

Pod 是什麼

Pod 是 Kubernetes 裡最小的部署單位,裡面裝一個或幾個容器。Kubernetes 不直接管容器,它管的是 Pod。

  • 比喻:一份餐點。客人點的是「一份套餐」,裡面可能只有主餐,也可能附一杯飲料(多個容器)
  • 來龍去脈:pod 是英文的「豆莢」,一個豆莢裡裝幾顆豆子;Docker 的標誌是鯨魚,一群鯨魚英文也叫 pod
  • 為什麼要學:你在 K8s 看到的狀態(Running、Pending、CrashLoopBackOff)幾乎都是 Pod 的狀態。Pod 的寫法會在第 11 篇:Pod 是什麼?寫第一個 YAML 把容器跑進 K8s細講,這篇先知道「Pod 是被派工的那一份工作」就好

控制平面:負責做決定的 4 個元件

控制平面(Control Plane)是 Kubernetes 的大腦:它不跑你的網站,只負責記住「應該要有什麼」、決定「放哪裡」、盯著「有沒有照做」。

  • 比喻:餐廳的外場辦公室,有櫃檯、訂單本、派單領班、巡場經理
  • 來龍去脈:舊文章常叫它 Master(主節點)。Kubernetes 社群後來改稱 control plane,kubeadm(官方的叢集安裝工具)已經不再使用 node-role.kubernetes.io/master 這個舊標記,改用 node-role.kubernetes.io/control-plane(Kubernetes 官方標籤說明,2026 年 11 月查)。你在下面實作會看到節點的角色寫的是 control-plane
  • 為什麼要學:控制平面掛了,叢集就「不能改」;但已經在跑的 Pod 不一定會停。這個差別是面試常考題,實作段落會實際證明
元件白話餐廳比喻壞掉會怎樣
kube-apiserver唯一的窗口,所有人(包括你的 kubectl)都只跟它講話點餐櫃檯什麼都查不到、改不了
etcd存放叢集所有設定和狀態的資料庫訂單本資料沒了=整個叢集失憶
kube-scheduler看到還沒分配節點的 Pod,幫它挑一個節點派單領班新 Pod 卡在 Pending
kube-controller-manager一直比對「應該有幾個」和「實際有幾個」,不一樣就修正巡場經理刪掉的 Pod 不會自動補

kube-apiserver:唯一的窗口

kube-apiserver 是控制平面的前門,它提供一組 HTTP 介面(API,Application Programming Interface,程式之間講話的固定格式),你打的每一個 kubectl 指令,其實都是送一個 HTTPS 請求給它。

它會先檢查你是誰、有沒有權限、格式對不對,通過了才把資料寫進 etcd。其他元件(排程器、控制器、每個節點的 kubelet)也都是透過它讀寫資料,彼此不直接講話。

etcd:叢集的帳本

etcd 是一個「鍵值資料庫」(key-value store):每筆資料就是「名字=內容」,像「pod/web-xxx=這個 Pod 的完整設定」。

  • 比喻:餐廳的訂單本,寫下每一張單「應該要做什麼」
  • 來龍去脈:名字來自 Linux 的 /etc 資料夾(放設定檔的地方)加上 d(distributed,分散式),意思是「分散在好幾台機器上的設定資料夾」
  • 為什麼要學:etcd 壞了又沒備份,叢集裡所有 Deployment、Service、Secret 的定義就都沒了。CKA 考試常考 etcd 的備份與還原

kube-scheduler:派工的領班

kube-scheduler 只做一件事:幫還沒有節點的 Pod 挑一個節點。它會先篩掉不合格的節點(例如記憶體不夠),再幫剩下的打分數,挑最高分的那台。

它只負責「填上節點名字」,不負責把容器跑起來。真正啟動容器的是那個節點上的 kubelet。

kube-controller-manager:一直對帳的經理

kube-controller-manager 是一個程式裡面裝了很多「控制器」(controller),每個控制器盯一種東西:Deployment 控制器盯 Deployment、ReplicaSet 控制器盯「Pod 數量對不對」、Node 控制器盯「節點還活著嗎」。

它們的工作方式都一樣:看期望狀態(你要的)→ 看實際狀態(現在有的)→ 不一樣就動手修,一直重複。這個不停對帳的迴圈,就是 Kubernetes 會「自我修復」的原因。

另外還有一個選配的 cloud-controller-manager,負責跟雲端服務商溝通(例如幫你在 Google Cloud 建一個負載平衡器)。Minikube 這種本機叢集沒有它。


節點:真的跑容器的 3 個元件

節點是叢集裡實際跑你應用程式的機器,每個節點上都有這三個元件(Kubernetes Components 官方頁):

元件白話餐廳比喻
kubelet節點上的組長:接到分配給自己的 Pod,就叫執行環境把容器跑起來,並且一直回報狀態工作檯組長
容器執行環境(Container Runtime)真的去拉映像檔、建立和啟動容器的軟體,例如 containerd、CRI-O爐子和廚師
kube-proxy(選配)在節點上設定網路規則,讓「打到某個 Service 的流量」被送到正確的 Pod傳菜動線

kubelet:每個節點的組長

kubelet 是每個節點上都會跑的一個程式,它會一直問 API 伺服器:「有沒有 Pod 分配給我?」有的話就照著 Pod 的設定,叫容器執行環境把容器跑起來,跑起來之後再定期回報「我這裡的 Pod 都還活著」。

kubelet 很特別:它本身不是 Pod,是直接裝在節點作業系統上的服務(作業系統是管理電腦硬體、讓其他程式能跑的底層軟體,像 Windows、Ubuntu)。所以你用 kubectl get pods 永遠看不到 kubelet,實作段落會證明這件事。

容器執行環境:真的煮菜的人

容器執行環境(Container Runtime)是真正負責建立、啟動、停止容器的軟體。Kubernetes 透過一個叫 CRI(Container Runtime Interface,容器執行環境介面)的標準接口跟它講話,所以可以換不同的實作。

來龍去脈:Kubernetes 早期直接支援 Docker,後來在 1.24 版移除了這段專門給 Docker 的程式(dockershim),現在主流是 containerd。Minikube 預設還是用 Docker,是透過一個叫 cri-dockerd 的轉接器接上 CRI;它啟動時也提醒「從 v1.39.0 起預設會改用 containerd」,你在實作會看到這行字。

kube-proxy:傳菜動線

kube-proxy 負責節點上的網路轉送規則,讓同一個服務名稱可以把流量平均分給背後好幾個 Pod。這部分會在第 13 篇講 Service 時細講。官方文件把它標成「選配」,因為有些網路外掛會自己做這件事。


一個 Pod 是怎麼被建出來的?

你下 kubectl create deployment web --image=nginx,叢集裡會依序發生這 7 件事:

一個 Pod 被建出來的 7 個步驟:kubectl 送給 API 伺服器、寫進 etcd、控制器建 Pod、排程器挑節點、kubelet 叫執行環境拉映像檔、啟動容器、回報 Running
  1. kubectl 把「我要一個叫 web 的 Deployment,用 nginx 映像檔」送給 kube-apiserver
  2. kube-apiserver 檢查權限和格式,通過後寫進 etcd
  3. Deployment 控制器看到新的 Deployment,建立一個 ReplicaSet;ReplicaSet 控制器發現「要 1 個 Pod、現在 0 個」,建立一個 Pod(這時 Pod 還沒有節點)
  4. kube-scheduler 看到這個沒分配節點的 Pod,挑一個節點填進去
  5. 那個節點的 kubelet 發現有 Pod 分配給自己,叫容器執行環境去拉 nginx 映像檔
  6. 容器執行環境建立並啟動容器
  7. kubelet 回報 Pod 狀態是 Running,API 伺服器再寫回 etcd

重點是:每個元件都只做自己那一小段,彼此透過 API 伺服器交接。實作的步驟 10 會用 kubectl get events 看到這幾個元件留下的紀錄,順序跟這張圖一模一樣。

宣告式:你寫「要什麼」,不是寫「怎麼做」

宣告式(Declarative)是指你只描述想要的結果,例如「我要 3 個 nginx」,不用寫「先開第 1 個、再開第 2 個」。

  • 比喻:你跟餐廳說「這桌要 3 份套餐」,不用教廚師怎麼煮;少上一份,經理會自己追
  • 來龍去脈:相反的叫命令式(Imperative),像第 2 篇的 docker run,你下一個指令它做一個動作,容器掛了它不會管。Kubernetes 存的是「期望狀態」,控制器一直把現實拉回期望狀態
  • 為什麼要學:這是 Kubernetes 會自我修復、可以用 YAML 檔管理一切的根本原因;面試問「K8s 跟 Docker 差在哪」,講出這點就有分
用一間餐廳記 K8s 架構:kube-apiserver 是點餐櫃檯、etcd 是訂單本、kube-scheduler 是派單領班、controller-manager 是巡場經理、kubelet 是工作檯組長、容器執行環境是爐子和廚師、Pod 是一份餐點

動手做:在 Cloud Shell 開一個 K8s 叢集,看看裡面住了誰

這段在 Cloud Shell(不用設專案) 做,不會花錢,大約 15 分鐘。怎麼打開 Cloud Shell 請看第 1 篇的步驟;如果跳出「授權 Cloud Shell」,這篇用不到 gcloud,按「拒絕」就好。

截圖裡的提示字元有縮短(跑過 export PS1='\w\$ '),你的畫面會是「你的帳號@cloudshell:~$」,不影響操作。

Minikube 是什麼? Minikube 是一個在單一台電腦上開出「迷你 Kubernetes 叢集」的工具,Kubernetes 官方社群維護(Minikube 官方文件),Cloud Shell 已經預裝。完整介紹和 kubectl 必學指令放在下一篇:第 10 篇:Minikube 教學:在 Cloud Shell 免費建 K8s 叢集+kubectl 必學指令。這篇只用它來「看」架構。

kubectl 是什麼? kubectl 是跟 Kubernetes 講話的指令工具,唸法有人唸「kube control」、有人唸「kube C T L」。它做的事就是把你的指令變成 HTTPS 請求送給 kube-apiserver。

步驟 1:確認工具版本

先看 Cloud Shell 裡的 Minikube 和 kubectl 是哪一版:

minikube version; kubectl version --client
minikube version: v1.38.1
commit: c93a4cb9311efc66b90d33ea03f75f2c4120e9b0
Client Version: v1.35.9-dispatcher
Kustomize Version: v5.7.1
Cloud Shell 執行 minikube version 和 kubectl version,顯示 Minikube v1.38.1、kubectl v1.35.9

Minikube 是 v1.38.1,kubectl 是 v1.35.9(後面的 -dispatcher 是 Google Cloud 打包的版本標記)。Kustomize 那行是 kubectl 內建的另一個工具,這系列用不到。

步驟 2:開一個 Kubernetes 叢集

minikube start
😄  minikube v1.38.1 on Ubuntu 24.04 (amd64)
    ▪ MINIKUBE_FORCE_SYSTEMD=true
    ▪ MINIKUBE_HOME=/google/minikube
    ▪ MINIKUBE_WANTUPDATENOTIFICATION=false
✨  Automatically selected the docker driver. Other choices: none, ssh
❗  Starting v1.39.0, minikube will default to "containerd" container runtime. See #21973 for more info.
📌  Using Docker driver with root privileges
👍  Starting "minikube" primary control-plane node in "minikube" cluster
🚜  Pulling base image v0.0.50 ...
💾  Downloading Kubernetes v1.35.1 preload ...
    > preloaded-images-k8s-v18-v1...:  272.45 MiB / 272.45 MiB  100.00% 20.73 M
    > gcr.io/k8s-minikube/kicbase...:  519.58 MiB / 519.58 MiB  100.00% 24.93 M
🔥  Creating docker container (CPUs=2, Memory=3072MB) ...
🧯  Docker is nearly out of disk space, which may cause deployments to fail! (95% of capacity). You can pass '--force' to skip this check.
(中間省略:清理硬碟的建議)
🐳  Preparing Kubernetes v1.35.1 on Docker 29.2.1 ...
    ▪ kubelet.cgroups-per-qos=false
    ▪ kubelet.enforce-node-allocatable=""
🔗  Configuring bridge CNI (Container Networking Interface) ...
🔎  Verifying Kubernetes components...
    ▪ Using image gcr.io/k8s-minikube/storage-provisioner:v5
🌟  Enabled addons: storage-provisioner, default-storageclass
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default
minikube start 的完整輸出:下載 Kubernetes v1.35.1、建立 2 顆 CPU 3072MB 記憶體的 docker 容器、啟動控制平面節點

這段輸出可以讀出幾件事:

  • primary control-plane node:Minikube 建的這個節點同時是控制平面和工作節點,一台機器包辦大腦和手腳
  • 第一次要下載兩個檔案,加起來 272.45+519.58=792 MiB(MiB 是 1024×1024 位元組,約等於 1.05 MB)
  • 這個節點配了 2 顆 CPU、3072MB(3 GB)記憶體
  • Docker is nearly out of disk space:這台 Cloud Shell 的 Docker 空間用到 95%,這只是警告,叢集還是建起來了

步驟 3:看叢集裡有幾個節點

kubectl get nodes
NAME       STATUS   ROLES           AGE   VERSION
minikube   Ready    control-plane   11s   v1.35.1
kubectl get nodes 顯示一個叫 minikube 的節點,STATUS 是 Ready,ROLES 是 control-plane
  • NAME minikube:只有一個節點,名字叫 minikube
  • STATUS Ready:kubelet 有正常回報,節點可以接工作
  • ROLES control-plane:這台跑著控制平面,舊文章會寫成 master
  • VERSION v1.35.1:這個節點上 kubelet 的版本

正式環境通常是 3 台控制平面節點(壞一台還有兩台)加上好幾台工作節點;Minikube 為了省資源,全部塞在 1 台裡。

步驟 4:這個「節點」其實是一個容器

Minikube 在 Cloud Shell 用的是 Docker 驅動程式,意思是它把「一台機器」做成一個 Docker 容器:

docker ps --format 'table {{.Names}}\t{{.Image}}\t{{.Status}}'
NAMES      IMAGE                                 STATUS
minikube   gcr.io/k8s-minikube/kicbase:v0.0.50   Up 30 seconds
docker ps 顯示 minikube 節點本身是一個用 kicbase 映像檔跑起來的 Docker 容器

這就是「容器裡跑容器」:Cloud Shell 的 Docker 跑了一個叫 minikube 的容器,這個容器裡面又裝了一整套 Kubernetes,你的 Pod 再跑在它裡面。正式環境的節點是真的虛擬機器,但對 Kubernetes 來說都一樣是「一個節點」。

步驟 5:找到控制平面的前門

kubectl cluster-info
Kubernetes control plane is running at https://192.168.49.2:8443
CoreDNS is running at https://192.168.49.2:8443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
kubectl cluster-info 顯示控制平面的位址是 https://192.168.49.2:8443

https://192.168.49.2:8443 就是 kube-apiserver 的地址:

  • 192.168.49.2 是 minikube 節點的 IP(IP 是網路上每台機器的門牌號碼)
  • 8443 是 Port(埠號,同一台機器上不同服務的「分機號碼」),Minikube 的 API 伺服器開在 8443
  • https 代表連線有加密,kubectl 每次都帶著憑證去敲這個門

CoreDNS 那行是叢集內的「電話簿」,讓 Pod 可以用名字找到彼此,第 13 篇講 Service 時會用到。

步驟 6:點名控制平面的元件

控制平面的元件在 Minikube 裡都是以 Pod 的形式跑在 kube-system 這個命名空間(Namespace)裡。命名空間是叢集裡的資料夾,用來把不同用途的東西分開放;系統元件放 kube-system,你自己建的東西預設放 default。

kubectl get pods -n kube-system -o wide
NAME                               READY   STATUS    RESTARTS   AGE   IP             NODE       NOMINATED NODE   READINESS GATES
coredns-7d764666f9-sz25f           1/1     Running   0          20s   10.244.0.2     minikube   <none>           <none>
etcd-minikube                      1/1     Running   0          27s   192.168.49.2   minikube   <none>           <none>
kube-apiserver-minikube            1/1     Running   0          25s   192.168.49.2   minikube   <none>           <none>
kube-controller-manager-minikube   1/1     Running   0          25s   192.168.49.2   minikube   <none>           <none>
kube-proxy-r55ft                   1/1     Running   0          21s   192.168.49.2   minikube   <none>           <none>
kube-scheduler-minikube            1/1     Running   0          26s   192.168.49.2   minikube   <none>           <none>
storage-provisioner                1/1     Running   0          24s   192.168.49.2   minikube   <none>           <none>
kubectl get pods -n kube-system 列出 7 個系統 Pod:coredns、etcd、kube-apiserver、kube-controller-manager、kube-proxy、kube-scheduler、storage-provisioner

把這 7 個 Pod 對回架構圖:

Pod屬於角色
kube-apiserver-minikube控制平面唯一的窗口
etcd-minikube控制平面帳本
kube-scheduler-minikube控制平面派工
kube-controller-manager-minikube控制平面對帳、補位
kube-proxy-r55ft節點網路轉送
coredns-7d764666f9-sz25f外掛(Addon)叢集內的 DNS 電話簿
storage-provisionerMinikube 外掛幫你自動建硬碟空間,第 16 篇會用

兩個值得注意的地方:

  • 控制平面 4 個元件的名字都是「元件名-節點名」(-minikube),而且 IP 都是節點的 192.168.49.2。這代表它們直接用節點的網路,因為它們是 kubelet 直接啟動的「靜態 Pod」(步驟 7 說明)
  • coredns 的 IP 是 10.244.0.2,這是 Pod 專用的網段,跟節點的 IP 不一樣。一般 Pod 都會拿到這種 IP

步驟 7:控制平面的設定檔放在節點上

API 伺服器是控制平面的前門,可是它自己也是一個 Pod。那是誰把它跑起來的?答案是節點上的 kubelet 直接讀一個資料夾裡的 YAML 檔(YAML 是一種用縮排表示層次的設定檔格式,Kubernetes 的設定幾乎都用它寫):

minikube ssh -- ls /etc/kubernetes/manifests
etcd.yaml  kube-apiserver.yaml  kube-controller-manager.yaml  kube-scheduler.yaml
minikube ssh 列出 /etc/kubernetes/manifests 資料夾裡的四個 YAML:etcd、kube-apiserver、kube-controller-manager、kube-scheduler

minikube ssh -- 指令 的意思是「進到 minikube 節點裡執行這個指令」。這個資料夾剛好放著控制平面 4 個元件的設定檔。

這種 Pod 叫 靜態 Pod(Static Pod):

  • 白話:不是透過 API 伺服器建的,而是 kubelet 直接看資料夾裡的檔案就跑起來的 Pod
  • 比喻:餐廳開門前,組長照著牆上貼的「開店檢查表」先把櫃檯和訂單本準備好;櫃檯開了之後,客人的單才能進來
  • 來龍去脈:這是為了解決「雞生蛋」的問題。API 伺服器還沒啟動時,沒有人能透過 API 建 Pod,所以控制平面自己要用這種不經過 API 的方式先跑起來(Kubernetes 官方說明:Static Pods)
  • 為什麼要學:CKA 考試會考「控制平面元件壞了怎麼修」,答案常常就是去改這個資料夾裡的 YAML。kubelet 會盯著這個資料夾,檔案一改、一搬走,Pod 就跟著變,步驟 12 的實驗就是用這招

步驟 8:kubelet 不是 Pod

kubectl get pods -n kube-system 列出的 7 個系統 Pod 裡沒有 kubelet。它在哪?

minikube ssh -- systemctl is-active kubelet docker; minikube ssh -- pgrep -a kubelet | cut -c1-120
active
active
2043 /var/lib/minikube/binaries/v1.35.1/kubelet --bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.conf --cgroups-
minikube ssh 查到 kubelet 和 docker 都是 active 的系統服務,kubelet 是一個一般程式而不是 Pod
  • systemctl is-active 是查詢「系統服務」狀態的指令,兩個 active 分別代表 kubelet 和 docker 這兩個服務都在跑
  • pgrep -a kubelet 找到 kubelet 是節點上編號 2043 的一般程式(程式在執行中就叫「程序」,每個程序有一個編號),執行檔在 /var/lib/minikube/binaries/v1.35.1/kubelet

所以 kubelet 和容器執行環境是直接裝在節點上的服務,不是 Pod。它們是負責「跑 Pod」的人,自己當然不能是 Pod。

步驟 9:建一個網站,看它被派到哪裡

kubectl create deployment web --image=nginx; sleep 25; kubectl get pods -o wide
deployment.apps/web created
NAME                   READY   STATUS    RESTARTS   AGE   IP           NODE       NOMINATED NODE   READINESS GATES
web-68d995574f-r885l   1/1     Running   0          25s   10.244.0.3   minikube   <none>           <none>
kubectl create deployment 建立 nginx 網站,Pod 狀態 Running、IP 10.244.0.3、被派到 minikube 節點

Deployment 是「幫你維持 Pod 數量和版本」的設定,第 12 篇會完整教,這裡先用它建 1 個 nginx 網站。sleep 25 是等 25 秒再看,讓映像檔有時間下載。

Pod 名字 web-68d995574f-r885l 可以拆成三段:web 是 Deployment 的名字、68d995574f 是它底下 ReplicaSet 的代號、r885l 是隨機產生的 5 個字。NODE minikube 就是排程器挑的節點。

步驟 10:看事件紀錄,誰做了什麼

每個元件做完事都會留一筆「事件」(Event),照時間排序就能看到分工:

kubectl get events --sort-by=.metadata.creationTimestamp | grep -v -i node
LAST SEEN   TYPE     REASON                    OBJECT                      MESSAGE
32s         Normal   Scheduled                 pod/web-68d995574f-r885l    Successfully assigned default/web-68d995574f-r885l to minikube
32s         Normal   SuccessfulCreate          replicaset/web-68d995574f   Created pod: web-68d995574f-r885l
32s         Normal   ScalingReplicaSet         deployment/web              Scaled up replica set web-68d995574f from 0 to 1
31s         Normal   Pulling                   pod/web-68d995574f-r885l    Pulling image "nginx"
25s         Normal   Pulled                    pod/web-68d995574f-r885l    Successfully pulled image "nginx" in 6.02s (6.02s including waiting). Image size: 163294089 bytes.
24s         Normal   Created                   pod/web-68d995574f-r885l    Container created
24s         Normal   Started                   pod/web-68d995574f-r885l    Container started
kubectl get events 依時間列出 Scheduled、SuccessfulCreate、ScalingReplicaSet、Pulling、Pulled、Created、Started 七筆事件

grep -v -i node 是把跟節點開機有關的事件濾掉,只留這個網站的。把每一行對回元件:

REASON誰寫的對應流程圖第幾步
ScalingReplicaSetDeployment 控制器第 3 步:建 ReplicaSet
SuccessfulCreateReplicaSet 控制器第 3 步:建 Pod
Scheduledkube-scheduler(default-scheduler)第 4 步:挑節點
Pulling、Pulledkubelet第 5 步:拉映像檔
Created、Startedkubelet第 6、7 步:啟動容器

前三行都是「32 秒前」,代表控制平面在同一秒內就做完決定;真正花時間的是拉映像檔:nginx 映像檔 163,294,089 位元組,約 163 MB,下載用了 6.02 秒。映像檔越大,這一步越久,這也是第 8 篇要把映像檔變小的原因。

想看某一個 Pod 的事件,也可以用 kubectl describe pod Pod名字,最下面的 Events 會多一欄 From,直接寫是誰做的。

步驟 11:刪掉 Pod,控制器馬上補

kubectl delete pod -l app=web; kubectl get pods
pod "web-68d995574f-r885l" deleted from default namespace
NAME                   READY   STATUS              RESTARTS   AGE
web-68d995574f-lxbjx   0/1     ContainerCreating   0          1s
刪掉 nginx Pod 之後,ReplicaSet 控制器在 1 秒內建出一個新名字的 Pod

-l app=web 是「刪掉所有標籤是 app=web 的 Pod」。刪完立刻看,已經有一個新名字(lxbjx)的 Pod 在建立中,AGE 1s。

這就是控制器在對帳:帳本上寫要 1 個,實際剩 0 個,於是馬上補一個。你沒有下任何「重開」的指令。

步驟 12:實驗,把排程器拿掉

接下來做一個破壞性的小實驗:把排程器的設定檔從 manifests 資料夾搬走,kubelet 就會把排程器的 Pod 停掉。這只能在練習用的叢集做,正式環境不要試。

minikube ssh -- sudo mv /etc/kubernetes/manifests/kube-scheduler.yaml /tmp/; sleep 40; kubectl get pods -n kube-system
NAME                               READY   STATUS    RESTARTS      AGE
coredns-7d764666f9-sz25f           1/1     Running   0             2m4s
etcd-minikube                      1/1     Running   0             2m11s
kube-apiserver-minikube            1/1     Running   0             2m9s
kube-controller-manager-minikube   1/1     Running   0             2m9s
kube-proxy-r55ft                   1/1     Running   0             2m5s
storage-provisioner                1/1     Running   1 (94s ago)   2m8s
把 kube-scheduler.yaml 搬走 40 秒後,kube-system 裡的 kube-scheduler-minikube 消失了,只剩 6 個系統 Pod

sudo mv 是用管理員權限搬移檔案。40 秒後再看,kube-scheduler-minikube 從清單上消失了,剩 6 個。

步驟 13:沒有排程器,新 Pod 卡在 Pending

把網站從 1 個擴成 3 個:

kubectl scale deployment web --replicas=3; sleep 10; kubectl get pods
deployment.apps/web scaled
NAME                   READY   STATUS    RESTARTS   AGE
web-68d995574f-4f5lc   0/1     Pending   0          10s
web-68d995574f-8975t   0/1     Pending   0          10s
web-68d995574f-lxbjx   1/1     Running   0          68s
沒有排程器時擴成 3 個 Pod,新的 2 個卡在 Pending,舊的 1 個照樣 Running

這個結果把分工講得很清楚:

  • 控制器還在,所以它照樣建出 2 個新 Pod(帳本上要 3 個)
  • 排程器不在,沒有人幫這 2 個 Pod 挑節點,它們就一直停在 Pending(等待中)
  • 原本那個 Pod(lxbjx)照樣 Running:控制平面少了一個元件,不會讓已經在跑的網站停掉

以後你看到 Pod 卡在 Pending,第一個要懷疑的就是「排程器找不到合適的節點」。正式環境的原因通常不是排程器不見,而是節點的 CPU、記憶體不夠,這會在第 18 篇排錯時示範。

步驟 14:把排程器放回去

minikube ssh -- sudo mv /tmp/kube-scheduler.yaml /etc/kubernetes/manifests/; sleep 45; kubectl get pods -o wide
NAME                   READY   STATUS    RESTARTS   AGE    IP           NODE       NOMINATED NODE   READINESS GATES
web-68d995574f-4f5lc   1/1     Running   0          68s    10.244.0.5   minikube   <none>           <none>
web-68d995574f-8975t   1/1     Running   0          68s    10.244.0.6   minikube   <none>           <none>
web-68d995574f-lxbjx   1/1     Running   0          2m6s   10.244.0.4   minikube   <none>           <none>
把 kube-scheduler.yaml 放回去 45 秒後,原本 Pending 的 2 個 Pod 都被排到 minikube 節點並且 Running

檔案放回去,kubelet 看到了就把排程器重新跑起來;排程器一上線,就把那 2 個 Pending 的 Pod 排進節點,45 秒後 3 個都是 Running。順便確認排程器回來了,也看一下 API 伺服器的版本:

kubectl get pods -n kube-system | grep scheduler; kubectl version
kube-scheduler-minikube            1/1     Running   0            54s
Client Version: v1.35.9-dispatcher
Kustomize Version: v5.7.1
Server Version: v1.35.1
kube-scheduler-minikube 重新出現且 Running,kubectl version 顯示 Server Version v1.35.1

Server Version 就是 kube-apiserver 的版本 v1.35.1。kubectl(v1.35.9)和它都是 1.35,官方規定 kubectl 可以跟 API 伺服器差一個小版本(例如 1.34~1.36 都能管 1.35 的叢集),差更多就可能有指令不相容(Kubernetes 版本差異政策)。


實測時的意外

1. Cloud Shell 的 Docker 空間只剩 5%

minikube start 跳出 Docker is nearly out of disk space ... (95% of capacity),叢集最後還是有建起來。同一天寫第 10 篇時用 docker system df 查,這台 Cloud Shell 的 Docker 只有 1 個映像檔(1.936GB),代表空間緊是因為 Cloud Shell 給 Docker 的系統碟本來就小,不是殘留太多東西。

練習用不影響,看到可以先不理。如果真的建失敗,再用 docker system prune -a 清掉沒在用的映像檔(它會先問你確定才刪)。

2. 控制平面的元件少一個,網站沒停

很多人以為「控制平面掛了,網站就掛了」。實測拿掉排程器時,原本的 nginx Pod 一直是 Running,只有「新的工作」排不進來。原因是容器是 kubelet 和容器執行環境在顧,它們都在節點上,不需要排程器。

但這不代表控制平面可以隨便掛:API 伺服器掛了,你就不能部署、不能擴展;控制器掛了,Pod 壞了沒人補。所以正式環境的控制平面通常放 3 份。

3. Minikube 預設的不是最新版 Kubernetes

這次叢集是 v1.35.1,但 Kubernetes 官方最新版已經是 1.37.1(2026 年 9 月 15 日發布)。官方同時維護最新的 3 個小版本(目前是 1.37、1.36、1.35),每個大約支援 1 年,所以 1.35 還在支援範圍內(2026 年 11 月查 Kubernetes Releases)。

Minikube 每一版會預設它測過的 Kubernetes 版本,想用別版可以加 --kubernetes-version=v1.37.1。學架構用 1.35 完全沒問題。

4. kubectl 刪除的訊息變長了

網路舊教學刪 Pod 的輸出是 pod "xxx" deleted,這次是 pod "web-68d995574f-r885l" deleted from default namespace,多寫了是從哪個命名空間刪的。意思一樣,看到不要以為出錯。


用完記得刪

Cloud Shell 和 Minikube 都不收錢,但 Minikube 會佔用 Cloud Shell 的硬碟和記憶體,用完刪掉比較乾淨:

kubectl delete deployment web; minikube delete
deployment.apps "web" deleted from default namespace
🔥  Deleting "minikube" in docker ...
🔥  Deleting container "minikube" ...
🔥  Removing /google/minikube/.minikube/machines/minikube ...
💀  Removed all traces of the "minikube" cluster.
kubectl delete deployment 刪掉網站,minikube delete 刪掉整個叢集

確認叢集和節點容器都不見了:

minikube status; docker ps
🤷  Profile "minikube" not found. Run "minikube profile list" to view all profiles.
👉  To start a cluster, run: "minikube start"
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
minikube status 顯示找不到 minikube,docker ps 沒有任何容器在跑

docker ps 是空的,代表當作節點的那個 minikube 容器也刪掉了。下一篇要用時再 minikube start 就好,下載過的檔案有留著,第二次會快一些。


到了 GCP 上叫什麼

Google Cloud 上跑 Kubernetes 的服務叫 GKE(Google Kubernetes Engine),架構完全一樣,差別在「誰負責管」:

元件自己裝(像 Minikube)GKE
控制平面(API 伺服器、etcd、排程器、控制器)自己顧、自己備份、自己升級Google 代管,kube-system 裡看不到 kube-apiserver 的 Pod
節點自己準備機器Standard 模式:你選 VM 規格、付 VM 的錢;Autopilot 模式:Google 管節點,照 Pod 要求的資源計費
叢集管理費沒有每個叢集每小時 0.10 美元

算一次叢集管理費:一個月以 730 小時算,0.10 × 730=73 美元。GKE 每個帳單帳戶每月有 74.40 美元的免費額度,可以抵掉 1 個區域(zonal)Standard 叢集或 1 個 Autopilot 叢集的管理費(2026 年 11 月查 GKE 定價頁)。叢集開越多,管理費就越多;節點和 Pod 用的資源另外算。

這部分會在第 24 篇:GKE 是什麼?Google Kubernetes Engine 教學:Autopilot 和 Standard 怎麼選詳細比較。

如果連節點都不想管,Google 還有 Cloud Run:你只給容器映像檔,連叢集都不用建,後面第 20 篇會教。


面試/證照會怎麼問

面試常見題

  • 「你下 kubectl apply 之後發生了什麼?」:照流程圖講 7 步,重點是「每個元件只做一段,都透過 API 伺服器交接」
  • 「控制平面掛了,應用程式會停嗎?」:已經在跑的 Pod 不會馬上停(kubelet 在顧),但不能部署、不能擴展,壞掉的 Pod 也沒人補。可以舉「拿掉排程器,新 Pod 卡 Pending、舊 Pod 照跑」的例子
  • 「etcd 是什麼?為什麼要備份?」:叢集所有狀態都存在 etcd,它壞了又沒備份,等於叢集失憶
  • 「kubelet 是 Pod 嗎?」:不是,它是節點上的系統服務,負責跑 Pod
  • 「Pod 一直 Pending,你會先查什麼?」:kubectl describe pod 看 Events,通常是排程器找不到資源夠的節點

Kubernetes 證照(CKA、CKAD)

Kubernetes 的證照是上機實作考,不是選擇題:考試時給你真的叢集,你要在終端機裡把事情做出來。

CKA(管理員)CKAD(應用程式開發者)
重點建叢集、維護、排錯部署和設定應用程式
跟這篇的關係「叢集架構、安裝與設定」25%、「排錯」30%,架構是核心架構考得少,但要懂 Pod 怎麼被排程
費用與形式445 美元、2 小時、實作、含 1 次補考、效期 2 年445 美元、2 小時、實作、含 1 次補考、效期 2 年

(2026 年 11 月查 CKA 官方頁,CKA 目前以 Kubernetes v1.37 出題)

CKA 常見的操作題:控制平面元件壞了,去 /etc/kubernetes/manifests 修 YAML;備份和還原 etcd;查節點為什麼 NotReady(通常是 kubelet 沒在跑)。

看到這些字,就想到這個

題目關鍵字想到
「所有請求的入口」「認證、授權」kube-apiserver
「叢集狀態存在哪」「備份與還原」etcd
「Pod 要放哪個節點」「Pending」kube-scheduler
「Pod 少了自動補」「期望狀態」kube-controller-manager
「節點 NotReady」「節點上負責跑 Pod」kubelet
「Service 的流量轉送規則」kube-proxy
「控制平面元件的 YAML 放哪」/etc/kubernetes/manifests(靜態 Pod)

常見問答

K8s 架構有哪些元件?

分兩半。控制平面有 kube-apiserver(窗口)、etcd(資料庫)、kube-scheduler(挑節點)、kube-controller-manager(對帳補位),雲端環境再加一個選配的 cloud-controller-manager。每個節點上有 kubelet(跑 Pod 的組長)、容器執行環境(真的啟動容器)、kube-proxy(網路轉送,選配)。

Master 節點和控制平面是一樣的東西嗎?

是。Master(主節點)是舊說法,現在 Kubernetes 官方統一叫控制平面(control plane),kubeadm 也已經不再使用 node-role.kubernetes.io/master 這個舊標記,改成 control-plane。網路上舊文章寫 Master,指的就是跑控制平面元件的那台機器。

控制平面掛了,網站會停嗎?

已經在跑的 Pod 通常不會馬上停,因為容器是節點上的 kubelet 和容器執行環境在顧。但你不能部署新版本、不能擴展,Pod 壞了也不會自動補。這次實測把排程器拿掉,舊的 nginx Pod 照樣 Running,新的 2 個 Pod 卡在 Pending。

為什麼 kubectl get pods 看不到 kubelet?

因為 kubelet 不是 Pod,它是直接裝在節點作業系統上的服務,負責把 Pod 跑起來。用 minikube ssh -- systemctl is-active kubelet 才看得到它是 active。容器執行環境也一樣。

控制平面的元件為什麼也是 Pod?誰把它們跑起來的?

它們是「靜態 Pod」:節點上的 kubelet 直接讀 /etc/kubernetes/manifests 資料夾裡的 YAML 檔把它們跑起來,不經過 API 伺服器。這樣才能解決「API 伺服器還沒啟動,就沒人能建 Pod」的雞生蛋問題。

Minikube 只有一個節點,跟正式環境差在哪?

Minikube 把控制平面和工作節點塞在同一台(而且那台還是一個 Docker 容器),方便練習。正式環境通常有 3 台控制平面節點加上多台工作節點,任何一台壞掉都不影響整體。元件和運作方式是一樣的,所以用 Minikube 學架構完全夠用。

Kubernetes 和 Docker 是什麼關係?

Docker 負責「把程式包成映像檔、在一台機器上跑容器」;Kubernetes 負責「在很多台機器上管理很多容器」。Kubernetes 1.24 起移除了直接支援 Docker 的 dockershim,現在主流的容器執行環境是 containerd;但用 Docker 建出來的映像檔,Kubernetes 照樣可以跑。


重點整理

  • K8s 架構分兩半:控制平面做決定(kube-apiserver、etcd、kube-scheduler、kube-controller-manager),節點跑容器(kubelet、容器執行環境、kube-proxy)
  • 所有元件都只跟 API 伺服器講話,叢集狀態存在 etcd;一個 Pod 被建出來要經過 7 步,用 kubectl get events 就看得到誰做了哪一步
  • 控制平面是靜態 Pod,kubelet 不是 Pod:控制平面的 YAML 放在節點的 /etc/kubernetes/manifests,kubelet 是節點上的系統服務
  • 實測拿掉排程器:新的 2 個 Pod 卡在 Pending、舊的照跑,放回去 45 秒內全部 Running
  • GKE 幫你管控制平面:每個叢集每小時 0.10 美元,一個月約 73 美元,每月 74.40 美元免費額度可以抵 1 個叢集

延伸閱讀

本系列

站上相關文章


Kubernetes 的架構看懂之後,接下來就是實際操作叢集。如果你想有系統地從容器一路學到在 Google Cloud 上部署服務,可以看看東東的 GCP 課程,或加 LINE 聊聊你現在的狀況,一起找出最適合你的學習順序。

Table of Contents
返回頂端