...
← Curs Kubernetes: toate lecțiile
Lecția 2 · Introducere

Clusterul: noduri și control plane

În lecția 1 ai văzut trei noduri și ai pornit un pod. Acum te uiți „sub capotă”: din ce piese e făcut un cluster Kubernetes, cine ia deciziile, cine pornește efectiv containerele și de ce totul trece printr-un singur punct, API serverul. Vei citi detaliile unui nod și vei descoperi că și componentele clusterului rulează ca poduri.

Dispeceratul și echipele din teren

Gândește-te la o firmă de livrări. Există un dispecerat care primește comenzile, ține evidența lor, decide care șofer pleacă la fiecare client și urmărește dacă livrarea s-a făcut. Și există echipele din teren: șoferii care chiar duc pachetele. Dispeceratul nu conduce nicio mașină, iar șoferii nu decid singuri unde merg.

Un cluster Kubernetes are exact aceeași împărțire:

ParteÎn analogieCe face
control planedispeceratulprimește cererile, ține starea dorită, decide unde rulează fiecare pod, corectează diferențele
noduri workerechipele din terenpornesc și supraveghează containerele, raportează înapoi ce se întâmplă

În laboratorul tău, academia-control-plane este dispeceratul, iar academia-worker și academia-worker2 sunt nodurile pe care rulează aplicațiile.

Control plane: patru componente

Control plane-ul nu este un singur program, ci câteva componente care lucrează împreună:

ComponentăRol
kube-apiserverAPI serverul: singura „ușă” a clusterului. Orice comandă kubectl, orice componentă internă vorbește doar cu el.
etcdbaza de date a clusterului (cheie-valoare). Aici se salvează tot: ce poduri vrei, ce noduri există, ce configurări ai.
kube-scheduleralege pe ce nod pornește fiecare pod nou, după resursele libere și regulile tale.
kube-controller-managerrulează „controllerele”: bucle care compară starea dorită cu cea reală și o corectează (de exemplu, repornesc copiile care lipsesc).
Totul trece prin API server

Componentele nu vorbesc direct între ele: scheduler-ul nu scrie în etcd și nici kubectl nu vorbește cu nodurile. Toți citesc și scriu prin API server, care verifică cererea (ești autentificat? ai voie?) și abia apoi o salvează în etcd. De aceea, dacă API serverul nu răspunde, nu mai poți schimba nimic în cluster, chiar dacă aplicațiile care rulează deja merg mai departe.

Nodurile worker: kubelet, kube-proxy și containerd

Pe fiecare nod rulează trei programe:

  • kubelet: „șeful de echipă” al nodului. Află de la API server ce poduri i-au fost date, le pornește, verifică dacă sunt sănătoase și raportează starea lor;
  • container runtime (aici containerd): programul care chiar descarcă imaginile și pornește containerele, ca Docker Engine la cursul de Docker;
  • kube-proxy: configurează rețeaua nodului, ca traficul trimis către un serviciu să ajungă la podurile potrivite (îl folosești din modulul 2).

Vezi detaliile nodurilor, inclusiv IP-ul fiecăruia și runtime-ul, cu -o wide (output lărgit):

kubectl get nodes -o wide
NAME                     STATUS   ROLES           AGE   VERSION   INTERNAL-IP   EXTERNAL-IP   OS-IMAGE                         KERNEL-VERSION     CONTAINER-RUNTIME
academia-control-plane   Ready    control-plane   15m   v1.31.2   172.18.0.2    <none>        Debian GNU/Linux 12 (bookworm)   6.8.0-49-generic   containerd://1.7.18
academia-worker          Ready    <none>          14m   v1.31.2   172.18.0.3    <none>        Debian GNU/Linux 12 (bookworm)   6.8.0-49-generic   containerd://1.7.18
academia-worker2         Ready    <none>          14m   v1.31.2   172.18.0.4    <none>        Debian GNU/Linux 12 (bookworm)   6.8.0-49-generic   containerd://1.7.18
  • INTERNAL-IP: adresa nodului în rețeaua clusterului (172.18.0.x, rețeaua Docker în care rulează kind);
  • OS-IMAGE și KERNEL-VERSION: sistemul de operare al nodului;
  • CONTAINER-RUNTIME: containerd://1.7.18, adică nodurile nu folosesc Docker pentru containere, ci containerd.
Bine de știut

Kubernetes rulează imaginile construite cu Docker fără nicio problemă: o imagine este un format standard (OCI), pe care îl înțeleg și Docker, și containerd.

Ce știe clusterul despre un nod

kubectl describe afișează tot ce știe clusterul despre un obiect, într-un format ușor de citit. Pentru un nod, rezultatul e lung, așa că filtrează-l cu grep, ca la cursul de Linux (-A 5 = linia găsită și încă 5 după ea):

kubectl describe node academia-worker | grep -A 5 Allocatable
Allocatable:
  cpu:                2
  ephemeral-storage:  61202244Ki
  hugepages-2Mi:      0
  memory:             4Gi
  pods:               110

Allocatable spune câte resurse poate da nodul podurilor: 2 CPU, 4 GiB de memorie și maximum 110 poduri. Scheduler-ul se uită la aceste cifre când alege un nod. Tot în describe găsești secțiunea Conditions, cu starea de sănătate:

kubectl describe node academia-worker | grep -A 5 Conditions
Conditions:
  Type             Status   LastHeartbeatTime                 LastTransitionTime                Reason                       Message
  ----             ------   -----------------                 ------------------                ------                       -------
  MemoryPressure   False    Thu, 15 Jan 2026 10:00:00 +0200   Thu, 15 Jan 2026 09:45:15 +0200   KubeletHasSufficientMemory   kubelet has sufficient memory available
  DiskPressure     False    Thu, 15 Jan 2026 10:00:00 +0200   Thu, 15 Jan 2026 09:45:15 +0200   KubeletHasNoDiskPressure     kubelet has no disk pressure
  PIDPressure      False    Thu, 15 Jan 2026 10:00:00 +0200   Thu, 15 Jan 2026 09:45:15 +0200   KubeletHasSufficientPID      kubelet has sufficient PID available

MemoryPressure, DiskPressure și PIDPressure pe False sunt vești bune (nodul nu duce lipsă de memorie, disc sau procese), iar Ready True înseamnă că kubelet-ul raportează că nodul poate primi poduri.

Componentele clusterului sunt și ele poduri

Surpriză: în kind (și în multe clustere instalate cu kubeadm), componentele control plane-ului rulează ca poduri, într-un spațiu separat numit kube-system. Opțiunea -n kube-system alege acel spațiu (îl vei folosi des din lecția 10):

kubectl get pods -n kube-system
NAME                                             READY   STATUS    RESTARTS   AGE
coredns-hqfb2jv2pc-gk5r5                         1/1     Running   0          14m
coredns-hqfb2jv2pc-zst2b                         1/1     Running   0          14m
etcd-academia-control-plane                      1/1     Running   0          14m
kindnet-jktsv                                    1/1     Running   0          14m
kindnet-tsv2q                                    1/1     Running   0          14m
kindnet-x6gdm                                    1/1     Running   0          14m
kube-apiserver-academia-control-plane            1/1     Running   0          14m
kube-controller-manager-academia-control-plane   1/1     Running   0          14m
kube-proxy-pj8rn                                 1/1     Running   0          14m
kube-proxy-q7clb                                 1/1     Running   0          14m
kube-proxy-smf5m                                 1/1     Running   0          14m
kube-scheduler-academia-control-plane            1/1     Running   0          14m
metrics-server-vnsvpfmtwd-7g288                  1/1     Running   0          12m
  • etcd-…, kube-apiserver-…, kube-scheduler-…, kube-controller-manager-…: componentele control plane-ului, toate pe nodul academia-control-plane;
  • kube-proxy-… și kindnet-…: câte unul pe fiecare nod (de aceea apar de trei ori); kindnet face rețeaua dintre poduri;
  • coredns-…: serverul DNS al clusterului, prin care aplicațiile își găsesc una alta după nume;
  • metrics-server-…: adună consumul de CPU și memorie (pentru kubectl top, mai târziu în curs).

Pe hartă, butonul kube-system arată și aceste poduri pe nodurile lor. De obicei le ascunzi, ca să vezi doar aplicațiile tale.

Ce se întâmplă când pornești un pod

Cu piesele de mai sus, drumul comenzii kubectl run salut --image=nginx:1.27 din lecția 1 arată așa:

1
kubectl trimite cererea „vreau podul salut” la API server;
2
API serverul o verifică și o salvează în etcd: podul există acum, dar nu are încă un nod (stare Pending);
3
scheduler-ul observă podul fără nod, alege un worker cu resurse libere și scrie alegerea, tot prin API server;
4
kubelet-ul de pe nodul ales vede că a primit un pod nou și îi cere lui containerd să descarce imaginea și să pornească containerul;
5
kubelet-ul raportează Running; tu vezi asta în kubectl get pods și pe hartă.
De ce nu rulează aplicații pe control plane

Nodul academia-control-plane are un taint (o „etichetă de respingere”) NoSchedule, așa că scheduler-ul nu pune poduri obișnuite pe el. Dispeceratul nu pleacă în livrări: așa componentele importante nu concurează cu aplicațiile pentru CPU și memorie.

Greșeală frecventă

Mesajul The connection to the server localhost:8080 was refused - did you specify the right host or port? nu vine de la aplicația ta, ci de la kubectl, care nu găsește API serverul (lipsește configurarea sau clusterul e oprit). Despre configurarea lui kubectl afli în lecția următoare.

În lumea reală

1Cloud: control plane gestionat

În EKS, AKS sau GKE furnizorul îți administrează control plane-ul: nu vezi podurile etcd sau apiserver, plătești doar nodurile worker.

2Copii de siguranță

Cine pierde etcd pierde tot clusterul, de aceea echipele de operare îi fac backup regulat.

3Interviu

„Ce face scheduler-ul?” și „Ce rol are kubelet-ul?” sunt întrebări clasice la interviurile de DevOps. Răspunsul scurt: scheduler-ul alege nodul, kubelet-ul pornește podul pe nod.

Exercițiul tău

Fă un inventar al clusterului: salvează lista podurilor din kube-system în fișierul ~/k8s/sistem.txt, apoi afișează detaliile nodului academia-worker2.

  • Salvează lista în fișier cu redirecționare: kubectl get pods -n kube-system > ~/k8s/sistem.txt.
  • Verifică fișierul cu cat ~/k8s/sistem.txt (trebuie să apară kube-apiserver).
  • Afișează detaliile nodului: kubectl describe node academia-worker2.
Semnul > trimite ieșirea unei comenzi într-un fișier, exact ca la cursul de Linux.

Soluția exercițiului

kubectl get pods -n kube-system > ~/k8s/sistem.txt
cat ~/k8s/sistem.txt
kubectl describe node academia-worker2
Excelent! Continuă cu lecția următoare →
terminalKubernetes
VerificareSe încarcă...
Mediul de lucru se încarcă. Poți citi lecția între timp.
Parcursul tău Primii pași cu Kubernetes Lecția 2 · Clusterul: noduri și control plane
Progres 0% 0 din 14
Lecția curentă 2 / 12 Introducere