Déan cur síos ar ailtireacht Kubernetes: control plane i gcoinne worker nodes agus a gcomhpháirteanna.

Question

IT Interview Practice · Accepted Answer

Tá dhá chineál meaisín i gcnuasach Kubernetes: an **control plane** (an "inchinn" a dhéanann cinntí agus a stórálann staid) agus **worker nodes** (áit a ritheann do Pods i ndáiríre). Tá tacar beag comhpháirteanna dea-shainithe ag gach ceann.

## An pictiúr mór

```text
┌──────────────── CONTROL PLANE (the brain) ────────────────┐
│                                                            │
│   kube-apiserver ── the front door; ALL comms go through it│
│        │                                                   │
│   etcd ───────── key-value store: the cluster's SOURCE OF  │
│                  TRUTH (all objects & desired state)       │
│   kube-scheduler ── decides WHICH node a new Pod runs on   │
│   controller-manager ── runs control loops (reconcilers)   │
└──────────────────────────┬─────────────────────────────────┘
                           │ (apiserver)
   ┌───────────────────────┼───────────────────────┐
┌──┴─── WORKER NODE ──┐ ┌──┴─── WORKER NODE ──┐  ...
│ kubelet             │ │ kubelet             │
│ kube-proxy          │ │ kube-proxy          │
│ container runtime   │ │ container runtime   │
│  └ Pods (your apps) │ │  └ Pods (your apps) │
└─────────────────────┘ └─────────────────────┘
```

## Comhpháirteanna an control plane

```text
kube-apiserver        An t-aon phointe iontrála. Nochtann an REST API; bailíochtaíonn &
                      buanaíonn objects go etcd. Ní labhraíonn kubectl, controllers, agus
                      kubelets ach LEIS an apiserver.
etcd                  Key-value store dáilte, comhsheasmhach. Coinníonn sé staid IOMLÁN an
                      chnuasaigh (inmhianaithe + reatha). Caill etcd = caill an cnuasach.
kube-scheduler        Faireann sé ar Pods gan node sannta agus roghnaíonn sé an node is fearr
                      (bunaithe ar resource requests, affinity, taints, srl.).
kube-controller-      Ritheann sé na control loops: node controller, replication (ReplicaSet),
manager               deployment, job, endpoints, srl. Tiomáineann gach lúb iarbhír → inmhianaithe.
cloud-controller-     (Ar cloud) comhtháthaíonn sé leis an soláthraí: load balancers, routes,
manager               saolré node.
```

## Comhpháirteanna an worker node

```text
kubelet          Gníomhaire an node. Labhraíonn sé leis an apiserver, tosaíonn/stopann containers
                 tríd an runtime, agus tuairiscíonn sé stádas Pod & node. Cuireann sé réaltacht an
                 node ag teacht leis na Pods atá sannta dó.
kube-proxy       Ríomhchláraíonn sé líonrú an node (iptables/IPVS) ionas go gcothromaítear IPanna
                 fíorúla Service go dtí na endpoints Pod cearta.
container runtime An bogearra a ritheann na containers i ndáiríre (containerd, CRI-O).
```

## Conas a shreabhann "kubectl apply" tríd an gcóras

```text
1. kubectl → kube-apiserver: "Teastaíonn Deployment le 3 replica uaim"
2. bailíochtaíonn an apiserver & scríobhann sé an t-object go etcd
3. feiceann controller-manager (deployment→replicaset controller) é, cruthaíonn sé 3 object Pod
4. feiceann an scheduler 3 Pod gan sannadh, sannann sé gach ceann do node (scríobhann ar ais tríd an apiserver)
5. feiceann kubelet gach node a Pods, deir sé leis an runtime images a tharraingt & containers a thosú
6. sreangaíonn kube-proxy líonrú Service ionas go sroicheann trácht na Pods nua
Is lúb WATCH + RECONCILE gach rud, arna idirghabháil ag an apiserver.
```

```bash
kubectl get nodes                 # liostaigh nodes (control-plane + workers)
kubectl get pods -n kube-system   # féach na comhpháirteanna control-plane / córais
kubectl get componentstatuses     # sláinte na bpríomhphíosaí control-plane
```

## Cén fáth a bhfuil sé tábhachtach

Is é a thuiscint ar an scoilt idir an control plane agus worker nodes — agus ról gach comhpháirte — a iompaíonn Kubernetes ó bhosca dubh go córas ar féidir leat réasúnaíocht a dhéanamh air agus é a oibriú, mar sin is croí-eolas é d'aon innealtóir meánleibhéil-nó-níos-airde. Is é an **control plane** an inchinn a dhéanann cinntí: is é an **kube-apiserver** an t-aon phríomhdhoras trína ndéanann gach comhpháirt agus úsáideoir cumarsáid; is é **etcd** an key-value store comhsheasmhach a choinníonn staid iomlán an chnuasaigh agus atá ina fhoinse na fírinne (a chailleadh ciallaíonn an cnuasach a chailleadh); cinneann an **scheduler** cén node ar a n-íslíonn gach Pod nua; agus ritheann an **controller-manager** na lúba athmhuintearais a thiomáineann an staid iarbhír go leanúnach i dtreo na staide inmhianaithe. Ar gach **worker node**, is é an **kubelet** an gníomhaire a chuireann containers an node ag teacht leis na Pods atá sannta dó, ríomhchláraíonn **kube-proxy** an líonrú a chuireann IPanna fíorúla Service ag ród chuig na Pods cearta, agus ritheann **container runtime** (containerd, CRI-O) na containers i ndáiríre. Nochtann feiceáil conas a shreabhann `kubectl apply` amháin tríd an gcóras seo — apiserver go etcd, controllers ag cruthú objects, scheduler ag cur Pods, kubelets ag tosú containers, kube-proxy ag sreangú líonrú, gach rud mar lúba watch-and-reconcile — an dearadh galánta, comhsheasmhach taobh thiar den ardán. Is í an tsamhail mheabhrach seo díreach a theastaíonn uait chun a dhífhabhtú cén fáth go bhfuil Pod sáite ag Pending (scheduler), cén fáth nach bhfreagraíonn an cnuasach (apiserver/etcd), nó cén fáth nach bhfuil Service ag ród (kube-proxy), rud a fhágann go bhfuil sé riachtanach chun cnuasaigh fhíora a oibriú agus a fhabhtcheartú.

An pictiúr mór

Comhpháirteanna an control plane

Comhpháirteanna an worker node

Conas a shreabhann "kubectl apply" tríd an gcóras

Cén fáth a bhfuil sé tábhachtach

Ceisteanna gaolmhara