...
Pregătire interviuri

100 de întrebări de interviu Kubernetes, cu răspunsuri

Întrebările despre Kubernetes care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs Kubernetes: primele 12 lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 50junior
  • 36mid
  • 14senior
  • 121 minde citit
Întrebări de interviu Kubernetes cu răspunsuri

La un interviu în care se verifică Kubernetes, întrebările vin de obicei în trei forme: teorie („ce face scheduler-ul”, „care e diferența dintre un Deployment și un StatefulSet”), manifeste YAML pe care trebuie să le citești și în care trebuie să găsești problema, și scenarii de depanare: un pod rămâne în Pending, un Service nu are endpoint-uri, o aplicație e repornită cu OOMKilled. Tot mai des primești și o sarcină practică, cu kubectl pe un cluster de test.

La nivel junior se așteaptă să înțelegi obiectele de bază (poduri, Deploymenturi, Service-uri, ConfigMap-uri, Secret-uri, volume), să citești ieșirea comenzilor kubectl și să știi primii pași de depanare. La nivel mid contează cum se comportă sistemul în producție: rollout-uri fără întreruperi, resurse și probe corecte, rețea și NetworkPolicy, RBAC, Helm și operarea nodurilor. Întrebările senior verifică judecata: securitate, multi-tenancy, upgrade-uri și reacția la incidente.

Citește întâi răspunsul scurt și încearcă să-l spui cu voce tare, apoi parcurge explicația completă și rulează comenzile pe un cluster local (kind sau minikube) ori în laboratorul cursului. Partea de CI/CD, cloud și Docker o găsești pe pagina de pregătire pentru meseria de DevOps / Cloud engineer și pe pagina Docker.

Arhitectură și concepte de bază

1 Junior

Ce înseamnă că Kubernetes funcționează declarativ și ce face un controller?

Răspuns scurt: Descrii starea dorită (de exemplu 3 replici ale unei imagini), iar controllerele compară continuu starea dorită cu cea reală și fac pașii necesari ca să le aducă împreună. Nu dai comenzi pas cu pas, ci declari rezultatul.

În modul imperativ spui „pornește un container aici”. În modul declarativ scrii un obiect, de exemplu un Deployment cu replicas: 3, și îl trimiți la API server. Obiectul are două părți: spec (ce vrei) și status (ce există acum).

Un controller este o buclă de reconciliere: citește obiectele de un anumit tip, compară spec cu realitatea și acționează. Controllerul de Deployment creează sau actualizează ReplicaSet-uri, controllerul de ReplicaSet creează sau șterge poduri, scheduler-ul alege noduri, iar kubelet-ul pornește containerele. Fiecare face o singură treabă și reacționează la schimbări.

Consecințe practice:

  • Dacă ștergi un pod al unui Deployment, apare altul, pentru că starea dorită spune tot 3.
  • Dacă un nod moare, podurile lui sunt recreate pe alte noduri, fără intervenție.
  • Aceeași comandă kubectl apply -f poate fi rulată de oricâte ori: rezultatul e același (idempotență), ceea ce face posibile GitOps și pipeline-urile simple.

De aceea, în Kubernetes nu repari lucrurile „de mână” în poduri: modifici starea dorită, iar sistemul converge spre ea.

Ce urmărește intervievatorul: Verifică dacă înțelegi modelul mental al întregului sistem. Greșeala tipică este să descrii Kubernetes ca pe un „docker run pe mai multe mașini”.

2 Junior

Ce rol au kubelet și kube-proxy pe fiecare nod și ce se întâmplă dacă unul dintre ele se oprește?

Răspuns scurt: Kubelet-ul primește podurile programate pe nod, le pornește prin runtime-ul de containere, rulează probe-urile și raportează starea. kube-proxy programează regulile de rețea pentru Services. Fără kubelet, nodul devine NotReady; fără kube-proxy, serviciile nu mai funcționează corect pe acel nod.

Fiecare nod de lucru rulează câteva componente:

  • kubelet: agentul nodului. Urmărește în API server podurile care au spec.nodeName egal cu numele nodului, cere runtime-ului de containere (containerd, CRI-O) să descarce imaginile și să pornească containerele, montează volumele, rulează liveness, readiness și startup probes și trimite înapoi statusul podurilor și al nodului (heartbeat prin obiecte Lease).
  • kube-proxy: transformă Services și EndpointSlices în reguli iptables, IPVS sau nftables, ca traficul către un ClusterIP să ajungă la un pod. În unele clustere, pluginul de rețea (de exemplu Cilium) îl înlocuiește.
  • runtime-ul de containere și pluginul CNI pentru rețeaua podurilor.

Dacă kubelet-ul se oprește, containerele deja pornite continuă de obicei să ruleze, dar nimeni nu le mai supraveghează: nodul trece în NotReady după aproximativ 40 de secunde, iar după un timp podurile primesc taint-ul de evacuare și sunt recreate în altă parte. Dacă kube-proxy se oprește, regulile existente rămân, dar schimbările de endpoint-uri nu mai ajung pe nod, deci traficul poate merge spre poduri care nu mai există.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi ce rulează efectiv pe un nod, nu doar pe control plane. Mulți candidați cred că kube-proxy e un proxy prin care trece fiecare pachet.

Eroarea, în practică:untolerated taint {node.kubernetes.io/unreachable}

3 Junior

Ce este un namespace și ce nu izolează un namespace?

Răspuns scurt: Un namespace grupează obiecte și le dă un spațiu de nume separat, cu RBAC, cote și politici proprii. Nu izolează rețeaua (podurile pot comunica între namespace-uri) și nu acoperă resursele de cluster, precum nodurile și PersistentVolume-urile.

Namespace-urile împart clusterul logic: magazin, plati, monitorizare. Două Deploymenturi se pot numi api în namespace-uri diferite, iar comenzile kubectl lucrează implicit într-un singur namespace (-n, sau namespace-ul contextului).

Ce se poate lega de un namespace:

  • RBAC: un RoleBinding dă drepturi doar în namespace-ul lui.
  • ResourceQuota și LimitRange: limite de resurse per echipă.
  • NetworkPolicy: reguli de trafic pentru podurile din namespace.
  • Pod Security Admission, prin etichete pe namespace.

Ce nu izolează un namespace:

  • Rețeaua: implicit, orice pod poate apela orice serviciu din alt namespace (api.plati.svc.cluster.local). Ai nevoie de NetworkPolicy pentru separare.
  • Nodurile: podurile din namespace-uri diferite rulează pe aceleași noduri și împart kernelul.
  • Resursele fără namespace: Node, PersistentVolume, StorageClass, ClusterRole, CRD-uri.

Verifici ce resurse au namespace cu kubectl api-resources --namespaced=true. Pentru izolare puternică între clienți care nu au încredere unii în alții, namespace-ul nu ajunge: se folosesc clustere separate sau noduri dedicate.

Ce urmărește intervievatorul: Se verifică dacă știi limitele unui concept folosit des ca graniță de securitate. Greșeala tipică este să crezi că podurile din namespace-uri diferite nu se pot vedea în rețea.

Eroarea, în practică:pods "web" not foundnamespaces "magazn" not found

4 Junior

Ce conține fișierul kubeconfig și cum lucrezi sigur cu mai multe clustere?

Răspuns scurt: Kubeconfig-ul are trei liste: clusters (adresa API server-ului și certificatul CA), users (credențiale) și contexts (combinații cluster + user + namespace). Contextul curent decide unde ajung comenzile, așa că îl verifici înainte de orice comandă riscantă.

Fișierul implicit e ~/.kube/config, iar variabila KUBECONFIG poate indica unul sau mai multe fișiere. Structura:

YAML
clusters:
- name: prod
  cluster:
    server: https://10.0.0.1:6443
users:
- name: ana-prod
  user:
    exec: {command: aws, args: [eks, get-token, --cluster-name, prod]}
contexts:
- name: prod
  context: {cluster: prod, user: ana-prod, namespace: magazin}
current-context: dev

Comenzi utile:

  • kubectl config get-contexts și kubectl config current-context.
  • kubectl config use-context prod schimbă contextul.
  • kubectl config set-context --current --namespace=magazin setează namespace-ul implicit.

Practici de siguranță: promptul shell-ului afișează contextul curent (kube-ps1 sau ceva similar), producția are un fișier kubeconfig separat sau credențiale cu drepturi doar de citire pentru oameni, iar scripturile primesc explicit --context și -n. Cel mai frecvent incident e o comandă de ștergere rulată pe producție crezând că ești pe dev.

Ce urmărește intervievatorul: Intervievatorul verifică experiența practică și disciplina operațională. Un candidat bun pomenește riscul contextului greșit.

Eroarea, în practică:connection to the server localhost:8080 was refusedno context exists with the name

5 Junior

Care e diferența dintre etichete (labels) și adnotări (annotations)? Ce face selectorul env in (dev,test),!canary?

Răspuns scurt: Etichetele sunt perechi scurte cheie-valoare folosite pentru selecție (Services, Deploymenturi, kubectl -l). Adnotările păstrează informații care nu se selectează (descrieri, configurări pentru unelte). Selectorul alege obiectele cu env egal cu dev sau test care nu au eticheta canary.

Etichetele sunt indexate și interogabile. Un Service găsește podurile prin selector, un Deployment își recunoaște podurile prin matchLabels, iar tu filtrezi cu kubectl get pods -l app=magazin. Valorile au maximum 63 de caractere și un format restrâns.

Adnotările nu se folosesc la selecție și pot conține texte lungi, JSON sau URL-uri. Exemple: kubernetes.io/change-cause pentru istoric, nginx.ingress.kubernetes.io/rewrite-target pentru controllerul de Ingress, prometheus.io/scrape, informații despre echipa responsabilă.

Selectorii au două forme:

  • pe egalitate: app=magazin,tier!=db;
  • pe mulțimi: env in (dev,test), env notin (prod), canary (eticheta există), !canary (eticheta lipsește).
BASH
kubectl get pods -l 'env in (dev,test),!canary' --show-labels

O convenție utilă sunt etichetele recomandate app.kubernetes.io/name, app.kubernetes.io/instance, app.kubernetes.io/version, folosite de Helm și de multe unelte. Atenție: schimbarea etichetelor unui pod îl poate scoate dintr-un Service sau dintr-un ReplicaSet, care va crea imediat un pod nou.

Ce urmărește intervievatorul: Testează înțelegerea mecanismului care leagă obiectele între ele. Greșeala tipică este să pui în etichete date mari sau să folosești adnotări pentru selecție.

Eroarea, în practică:unable to parse requirementalready has a value, and --overwrite is false

6 Mid

Ce stochează etcd, de ce are nevoie de backup și ce se întâmplă dacă devine indisponibil?

Răspuns scurt: etcd stochează toată starea clusterului: toate obiectele trimise prin API. Fără backup, pierderea lui înseamnă pierderea clusterului. Dacă etcd e indisponibil, API server-ul nu mai acceptă scrieri, dar podurile deja pornite continuă să ruleze.

etcd este o bază de date cheie-valoare distribuită, cu consens Raft. Doar API server-ul vorbește cu ea; toate celelalte componente trec prin API. În etcd se află Deploymenturi, Secret-uri, ConfigMap-uri, Lease-uri, evenimente, deci tot ce ai declarat.

De ce contează backup-ul: dacă se pierd datele etcd, clusterul nu mai știe ce trebuie să ruleze. Nodurile ar continua să ruleze containerele existente, dar nimeni nu le-ar mai gestiona. Backup-ul se face cu etcdctl snapshot save (cu certificatele potrivite), periodic, și se testează restaurarea. În clusterele gestionate (EKS, GKE, AKS), furnizorul se ocupă de etcd, dar tot trebuie să ai manifestele în git și backup pentru volume.

Raft cere majoritate: cu 3 membri suporți căderea unuia, cu 5, a doi. Un număr par nu aduce toleranță în plus.

Când etcd nu are quorum:

  • API server-ul nu poate scrie, deci kubectl apply eșuează;
  • controllerele și scheduler-ul nu pot face schimbări;
  • podurile existente rulează în continuare, iar traficul spre ele merge, dar nimic nu se mai repară automat.

Performanța etcd depinde mult de latența discului, de aceea se recomandă SSD-uri dedicate.

Ce urmărește intervievatorul: Arată dacă ai o imagine completă a control plane-ului și a riscurilor operaționale. Mulți candidați nu știu că aplicațiile continuă să ruleze fără control plane.

7 Mid

Cum alege scheduler-ul nodul pentru un pod și ce poți influența ca dezvoltator?

Răspuns scurt: Scheduler-ul filtrează nodurile care pot rula podul (resurse, taints, afinități, volume), apoi le notează după criterii precum echilibrarea resurselor și răspândirea, și îl leagă de nodul cu scorul cel mai mare. Influențezi prin requests, nodeSelector, afinități, tolerations și topologySpreadConstraints.

Scheduler-ul urmărește podurile fără spec.nodeName. Pentru fiecare, trece prin două faze:

  • Filtrare: elimină nodurile care nu pot rula podul. Exemple: nu au destul CPU sau memorie liberă față de requests (nu față de consumul real), au un taint pe care podul nu-l tolerează, nu se potrivesc cu nodeSelector sau cu nodeAffinity obligatorie, nu pot atașa volumul cerut (zona discului) ori au portul hostPort ocupat.
  • Scorare: dintre nodurile rămase, le ordonează după preferințe: echilibrarea resurselor, preferredDuringScheduling din afinități, imaginea deja descărcată, răspândirea podurilor aceluiași serviciu.

Apoi scrie legătura (binding), iar kubelet-ul nodului ales pornește podul. Dacă niciun nod nu trece filtrarea, podul rămâne Pending, iar evenimentul FailedScheduling spune motivul pentru fiecare categorie de noduri, de exemplu 0/3 nodes are available: 2 Insufficient cpu, 1 node(s) had untolerated taint.

Ca dezvoltator, ce influențezi direct: resources.requests (cel mai important), nodeSelector, affinity, tolerations, topologySpreadConstraints și priorityClassName. Scheduler-ul nu mută podurile după plasare; pentru reechilibrare există unelte separate, precum descheduler.

Ce urmărește intervievatorul: Se verifică dacă știi de ce un pod ajunge Pending și cum citești mesajul. Greșeala tipică este să crezi că scheduler-ul se uită la consumul real al nodurilor.

Eroarea, în practică:node(s) didn't match Pod's node affinity/selector

8 Mid

Ce sunt owner references și ce înseamnă ștergerea în cascadă foreground, background și orphan?

Răspuns scurt: ownerReferences leagă un obiect de proprietarul lui (pod → ReplicaSet → Deployment). Garbage collector-ul șterge copiii când dispare proprietarul. Background șterge proprietarul imediat și copiii după; foreground șterge întâi copiii; orphan îi lasă în viață.

Când un ReplicaSet creează un pod, pune în metadata.ownerReferences al podului numele și UID-ul ReplicaSet-ului, cu controller: true. La fel, ReplicaSet-ul are ca proprietar Deploymentul. Lanțul îl vezi cu:

BASH
kubectl get pod magazin-7d9f-x2kq9 -o jsonpath='{.metadata.ownerReferences[0].kind}'

Garbage collector-ul din kube-controller-manager șterge obiectele al căror proprietar nu mai există. Moduri de ștergere:

  • --cascade=background (implicit): proprietarul dispare imediat, iar copiii sunt șterși apoi, în fundal.
  • --cascade=foreground: proprietarul primește un finalizer și rămâne vizibil, cu deletionTimestamp, până când toți copiii blocanți sunt șterși.
  • --cascade=orphan: proprietarul e șters, iar copiii rămân, fără proprietar.

Orphan e util în cazuri reale: recreezi un StatefulSet ca să schimbi un câmp imutabil, fără să oprești podurile; noul StatefulSet le adoptă dacă selectorul se potrivește. La fel, un ReplicaSet adoptă podurile orfane cu etichete potrivite, de aceea etichetele trebuie să fie unice între aplicații.

Owner references funcționează doar în același namespace sau de la un obiect de cluster.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că înțelegi cum se leagă obiectele și cum eviți ștergeri neintenționate. Puțini candidați știu de --cascade=orphan și de adopție.

9 Mid

De ce rămâne un obiect blocat în Terminating și cum procedezi corect?

Răspuns scurt: Obiectul are finalizeri: chei în metadata.finalizers care cer unui controller să facă o curățenie înainte de ștergere. Până nu sunt scoase, obiectul rămâne cu deletionTimestamp. Afli ce finalizer e, de ce controllerul nu-l scoate și repari cauza; scoaterea forțată e ultima soluție.

Când ștergi un obiect cu finalizeri, API server-ul nu-l elimină, ci îi pune deletionTimestamp. Controllerul care a adăugat finalizerul face curățenia (șterge un load balancer din cloud, un disc, obiectele dependente) și apoi scoate cheia. Când lista e goală, obiectul dispare.

Exemple frecvente:

  • kubernetes.io/pvc-protection: PVC-ul e încă montat de un pod.
  • kubernetes pe un namespace: încă se șterg obiecte din el sau un API agregat nu răspunde.
  • foregroundDeletion: se așteaptă ștergerea copiilor.
  • finalizeri ai unui operator care a fost dezinstalat înaintea resurselor lui.

Pași:

BASH
kubectl get pvc date -o jsonpath='{.metadata.finalizers}'
kubectl describe pvc date        # Used By, evenimente
kubectl get ns vechi -o yaml     # status.conditions

Apoi repari cauza: oprești podul care folosește PVC-ul, reinstalezi operatorul ca să-și termine curățenia, repari API-ul indisponibil.

Scoaterea manuală a finalizerului (kubectl patch ... -p '{"metadata":{"finalizers":null}}' --type=merge) obiectul dispare, dar curățenia nu se mai face: pot rămâne discuri sau load balancere plătite în cloud. O folosești doar când știi că resursa externă nu mai există.

Ce urmărește intervievatorul: Testează experiența reală de depanare. Răspunsul slab este „scot finalizerul”, fără să înțelegi ce protejează.

Eroarea, în practică:namespace is being terminated

10 Senior

Ce sunt CRD-urile și operatorii? Când ai scrie sau ai alege un operator?

Răspuns scurt: Un CRD adaugă un tip nou de obiect în API (de exemplu PostgresCluster). Un operator e un controller care urmărește acele obiecte și automatizează operațiile unei aplicații: instalare, backup, failover, upgrade. Îl alegi pentru sisteme cu stare și operații complexe, nu pentru aplicații stateless simple.

CustomResourceDefinition extinde API server-ul: după ce o aplici, poți face kubectl get postgresclusters, cu validare prin schemă OpenAPI, RBAC și kubectl explain, ca la orice obiect nativ. Singur, CRD-ul doar stochează date.

Operatorul aduce comportamentul: un controller care rulează în cluster, urmărește obiectele tipului nou și reconciliază. Exemplu: aplici

YAML
apiVersion: postgresql.cnpg.io/v1
kind: Cluster
metadata: {name: pg}
spec:
  instances: 3
  storage: {size: 20Gi}

iar operatorul creează podurile, configurează replicarea, face failover când primarul cade și programează backup-uri. Cunoștințele unui administrator devin cod.

Când merită: baze de date, cozi de mesaje, certificate (cert-manager), monitorizare (Prometheus Operator), adică sisteme unde ciclul de viață are multe etape. Când nu merită să scrii unul: o aplicație web stateless, unde un Deployment, un Helm chart sau Kustomize ajung.

Criterii de alegere pentru un operator existent: maturitate și comunitate, cum face upgrade-ul propriu, ce se întâmplă cu datele dacă îl dezinstalezi, drepturile RBAC pe care le cere. Pentru scriere, se folosesc Kubebuilder sau Operator SDK, cu controller-runtime în Go.

Ce urmărește intervievatorul: Se verifică viziunea asupra extensibilității și judecata tehnică. Greșeala tipică este să propui un operator pentru orice problemă.

Eroarea, în practică:the server doesn't have a resource type

Poduri și containere

11 Junior

De ce unitatea de bază în Kubernetes e podul, nu containerul? Ce împart containerele aceluiași pod?

Răspuns scurt: Podul grupează containere care trebuie să ruleze împreună pe același nod. Ele împart adresa IP și porturile (comunică prin localhost), volumele declarate în pod și ciclul de viață. Kubernetes programează, scalează și repornește poduri, nu containere individuale.

Un pod modelează un „calculator logic” pentru o aplicație. Containerele din el:

  • au același network namespace: aceeași adresă IP, aceleași porturi (două containere nu pot asculta pe același port) și comunică prin localhost;
  • pot împărți volume (de exemplu un emptyDir în care unul scrie și altul citește);
  • sunt programate împreună pe același nod și pornesc și se opresc odată cu podul;
  • pot împărți opțional spațiul de procese (shareProcessNamespace: true).

De ce nu container direct: unele aplicații au nevoie de procese ajutătoare strâns legate (un proxy, un colector de loguri, un init care pregătește fișiere). Fără pod, ar trebui să le pui pe toate în aceeași imagine sau să garantezi altfel că ajung pe aceeași mașină.

Regula practică: un pod pentru o singură aplicație principală, plus eventual sidecar-uri. Nu pune frontend-ul și backend-ul în același pod: nu le mai poți scala separat, iar un crash al unuia afectează podul întreg.

Podurile sunt efemere: au IP-uri noi la fiecare recreare, de aceea nu le apelezi direct, ci prin Services.

Ce urmărește intervievatorul: Verifică înțelegerea modelului de bază. Greșeala tipică este să pui mai multe aplicații independente în același pod.

Eroarea, în practică:container is not valid for pod

12 Junior

Citește această ieșire și spune ce se întâmplă cu fiecare pod.

NAME                     READY   STATUS             RESTARTS      AGE
api-6f7c9d8b5-4kq2p      1/2     Running            0             5m
api-6f7c9d8b5-9xz7r      0/1     CrashLoopBackOff   6 (40s ago)   8m
web-5d4b8c7f9-ltm2s      0/1     Pending            0             3m
job-raport-k2x9p         0/1     Completed          0             1h

Răspuns scurt: Primul pod are două containere, dar doar unul e pregătit (probabil readiness sau un sidecar). Al doilea cade repetat la pornire. Al treilea nu a fost programat pe niciun nod. Al patrulea e un job care s-a terminat cu succes.

Coloanele:

  • READY x/y: câte containere sunt pregătite din câte are podul. 1/2 înseamnă că un container rulează, dar nu trece readiness probe-ul (sau încă pornește). Podul nu primește trafic de la Services până nu e complet pregătit.
  • STATUS: rezumat calculat de kubectl din faza podului și motivele containerelor. CrashLoopBackOff nu e o fază, ci motivul de așteptare: containerul a ieșit de mai multe ori, iar kubelet-ul așteaptă tot mai mult între reporniri (până la 5 minute).
  • RESTARTS: câte reporniri ale containerelor au fost, iar (40s ago) arată cea mai recentă.

Ce faci pentru fiecare:

BASH
kubectl describe pod api-6f7c9d8b5-4kq2p      # care container nu e Ready, ce probe pică
kubectl logs api-6f7c9d8b5-9xz7r --previous   # jurnalul încercării anterioare
kubectl describe pod web-5d4b8c7f9-ltm2s      # FailedScheduling: resurse, taints, PVC

Completed la job-raport e normal: containerul a ieșit cu codul 0, iar podul rămâne pentru jurnal până e curățat (de exemplu cu ttlSecondsAfterFinished). Pentru mai multe detalii, kubectl get pods -o wide adaugă nodul și IP-ul.

Ce urmărește intervievatorul: Intervievatorul verifică dacă citești rapid starea clusterului și știi primul pas pentru fiecare caz. Mulți confundă READY cu STATUS.

Eroarea, în practică:ErrImagePullBack-off pulling image (ImagePullBackOff)

13 Junior

Care e diferența dintre faza unui pod (status.phase) și starea containerelor lui? Dă exemple.

Răspuns scurt: Faza e un rezumat grosier al podului: Pending, Running, Succeeded, Failed sau Unknown. Starea fiecărui container e mai precisă: Waiting (cu motiv, de exemplu ImagePullBackOff), Running sau Terminated (cu exit code și motiv, de exemplu OOMKilled). Depanarea se face pe starea containerelor.

Fazele podului:

  • Pending: podul a fost acceptat, dar nu toate containerele rulează. Include atât „neprogramat”, cât și „imaginea se descarcă”.
  • Running: podul e pe un nod și cel puțin un container rulează sau repornește.
  • Succeeded: toate containerele au ieșit cu 0 și nu vor fi repornite (joburi).
  • Failed: toate containerele s-au terminat, cel puțin unul cu eroare.
  • Unknown: nodul nu mai raportează.

Starea containerelor e în status.containerStatuses:

BASH
kubectl get pod api -o jsonpath='{.status.containerStatuses[0].state}'
# {"waiting":{"reason":"CrashLoopBackOff","message":"back-off 1m20s ..."}}
kubectl get pod api -o jsonpath='{.status.containerStatuses[0].lastState.terminated.exitCode}'

Motive frecvente: ContainerCreating, ErrImagePull, ImagePullBackOff, CreateContainerConfigError (Waiting); Completed, Error, OOMKilled (Terminated).

Capcana: un pod în CrashLoopBackOff are faza Running, pentru că podul există pe nod și containerul repornește. Un monitor care verifică doar faza îl consideră sănătos. De aceea alertele se construiesc pe readiness și pe numărul de reporniri, nu pe fază.

Ce urmărește intervievatorul: Se verifică dacă știi unde să cauți informația precisă. Greșeala tipică este să crezi că Running înseamnă „aplicația merge”.

14 Junior

Ce face restartPolicy și ce valoare folosești pentru un Deployment, un Job și un pod de depanare?

Răspuns scurt: restartPolicy spune kubelet-ului ce face când un container iese: Always îl repornește mereu, OnFailure doar la cod diferit de 0, Never niciodată. Deploymenturile acceptă doar Always, Joburile cer OnFailure sau Never, iar un pod de test temporar folosește de obicei Never.

Politica se aplică tuturor containerelor din pod și e executată local de kubelet, în același pod (podul nu e recreat). Repornirile au backoff exponențial: 10 s, 20 s, 40 s, până la 5 minute, de unde vine starea CrashLoopBackOff.

  • Always (implicit): pentru servicii care trebuie să ruleze continuu. Deploymenturile, StatefulSet-urile și DaemonSet-urile acceptă doar această valoare.
  • OnFailure: containerul e repornit doar dacă iese cu eroare. Potrivit pentru joburi care pot reîncerca în același pod (păstrează volumele emptyDir).
  • Never: containerul nu e repornit. La Joburi, la eșec, controllerul creează un pod nou, iar podurile eșuate rămân pentru jurnale.
BASH
kubectl run test --image=busybox:1.36 --restart=Never --rm -it -- sh
kubectl create job export --image=academia/raport:1.0   # pune singur Never

Cu --restart=Never, kubectl run creează un pod simplu, care nu revine după ce iese. Atenție la Joburi: dacă folosești OnFailure și containerul cade din cauza unei erori permanente, repornirile din același pod se numără tot în backoffLimit, dar jurnalele încercărilor anterioare sunt mai greu de găsit.

Ce urmărește intervievatorul: Intervievatorul verifică legătura dintre politica de repornire și tipul de workload. Greșeala tipică este să crezi că restartPolicy recreează podul.

Eroarea, în practică:CrashLoopBackOff cu Completed, Exit Code 0Job: restartPolicy: Required value

15 Junior

Ce sunt init containers și când le folosești? Scrie un exemplu care așteaptă baza de date.

Răspuns scurt: Init containers rulează unul după altul înaintea containerelor aplicației și trebuie să termine cu succes. Le folosești pentru pregătiri: așteptarea unei dependențe, migrări simple, descărcarea sau generarea unor fișiere de configurare.

Fiecare init container pornește doar după ce precedentul a ieșit cu 0. Dacă unul eșuează, kubelet-ul îl repornește (după restartPolicy), iar podul stă în Init:0/1 sau Init:CrashLoopBackOff. Containerele aplicației pornesc abia după ce toate au terminat.

Exemplu: API-ul așteaptă ca serviciul postgres să răspundă la DNS și pe port:

YAML
spec:
  initContainers:
  - name: asteapta-db
    image: busybox:1.36
    command: ["sh", "-c", "until nc -z postgres 5432; do echo astept; sleep 2; done"]
  containers:
  - name: api
    image: academia/api:1.0

Avantaje: imaginea aplicației nu trebuie să conțină unelte de pregătire, iar init-ul poate avea alte drepturi sau alt user. Pot partaja fișiere prin volume emptyDir.

Limite: un init care așteaptă la nesfârșit blochează podul fără să fie evident de ce, deci pune un mesaj în jurnal. Așteptarea dependențelor nu înlocuiește logica de reîncercare din aplicație: baza de date poate cădea și după pornire. Migrările de schemă rulate în init container rulează la fiecare pod, deci au nevoie de blocare sau sunt mai bine mutate într-un Job separat.

Ce urmărește intervievatorul: Se verifică dacă știi ordinea de pornire și limitele mecanismului. Mulți candidați uită că init-ul rulează la fiecare repornire a podului.

Eroarea, în practică:Init:0/1: podul rămâne în init containerInit:CrashLoopBackOff

16 Junior

Un coleg îți spune că aplicația lui „nu merge în Kubernetes”. Care sunt primele cinci comenzi pe care le rulezi și ce cauți în fiecare?

Răspuns scurt: Rulez kubectl get pods -o wide (starea), kubectl describe pod (evenimente și motive), kubectl logs (cu --previous dacă repornește), kubectl get endpoints sau describe svc (dacă traficul ajunge la poduri) și kubectl exec sau port-forward ca să testez aplicația din interior.

Ordinea merge de la general la particular:

BASH
kubectl get pods -n magazin -o wide -l app=api
kubectl describe pod api-6f7c9d8b5-4kq2p -n magazin
kubectl logs api-6f7c9d8b5-4kq2p -n magazin --previous
kubectl get svc,endpoints api -n magazin
kubectl port-forward svc/api 8080:80 -n magazin

Ce urmăresc:

  • get pods: există poduri, sunt Ready, au reporniri, rulează pe noduri diferite.
  • describe: secțiunea Events (FailedScheduling, ErrImagePull, Unhealthy de la probe), Last State cu exit code, limitele de resurse.
  • logs: excepția aplicației; --previous arată jurnalul containerului care a căzut, nu al celui care tocmai a pornit; -c alege containerul.
  • endpoints: dacă e gol, selectorul serviciului nu se potrivește sau podurile nu sunt Ready.
  • port-forward: dacă răspunde direct, problema e mai sus (Ingress, DNS, rețea).

Apoi kubectl get events -n magazin --sort-by=.lastTimestamp pentru context și kubectl exec -it POD -- sh pentru testare din pod (de exemplu dacă API-ul ajunge la baza de date). Întreb și ce s-a schimbat ultima dată: un rollout, o configurare, un Secret.

Ce urmărește intervievatorul: Intervievatorul verifică un proces sistematic de depanare. Răspunsul slab sare direct la repornirea podurilor.

Eroarea, în practică:Back-off pulling image (ImagePullBackOff)Back-off restarting failed container

17 Junior

De ce nu rulezi o aplicație de producție ca pod simplu, creat direct, ci printr-un Deployment?

Răspuns scurt: Un pod creat direct nu e recreat dacă nodul cade sau dacă îl ștergi, nu poate fi scalat și nu are rolling update. Deploymentul păstrează numărul de replici, înlocuiește podurile căzute, permite actualizări fără întrerupere și rollback.

Un pod „gol” (fără controller) e legat de nodul pe care a fost programat. Kubelet-ul repornește containerele din el după restartPolicy, dar dacă:

  • nodul se defectează sau e golit pentru mentenanță (kubectl drain),
  • podul e evacuat din lipsă de memorie pe nod,
  • cineva îl șterge din greșeală,

nimeni nu-l recreează. În plus, majoritatea câmpurilor unui pod sunt imutabile, deci o imagine nouă înseamnă ștergere și recreare, cu întrerupere.

Deploymentul adaugă: replici multiple (disponibilitate și capacitate), autoreparare prin ReplicaSet, rolling update cu maxSurge și maxUnavailable, istoric de revizii cu rollout undo și integrare cu HPA. kubectl drain refuză chiar să golească un nod cu poduri fără controller, decât cu --force, tocmai pentru că s-ar pierde.

Podurile simple au totuși rostul lor: depanare temporară (kubectl run test --rm -it), comenzi unice de administrare sau exerciții. Pentru sarcini care trebuie să termine, folosești Job, iar pentru câte un pod pe nod, DaemonSet.

Ce urmărește intervievatorul: Se verifică dacă știi ce aduc controllerele. Greșeala tipică este să crezi că restartPolicy: Always ajunge pentru disponibilitate.

Eroarea, în practică:pod updates may not change fields other thancannot delete Pods declare no controller

18 Junior

Ce este Downward API și cum îi dai aplicației numele podului și limita de memorie?

Răspuns scurt: Downward API expune informații despre pod (nume, namespace, IP, nod, etichete, resurse) aplicației, ca variabile de mediu sau fișiere, fără ca aplicația să apeleze API-ul Kubernetes. Le citești cu fieldRef și resourceFieldRef.

Aplicațiile au uneori nevoie de date despre propriul pod: numele lui în loguri sau metrici, namespace-ul, limita de memorie ca să-și dimensioneze cache-ul sau heap-ul. În loc să le dai drepturi RBAC ca să citească podul din API, folosești Downward API:

YAML
containers:
- name: api
  image: academia/api:1.0
  resources:
    limits: {memory: 512Mi}
  env:
  - name: POD_NAME
    valueFrom: {fieldRef: {fieldPath: metadata.name}}
  - name: POD_NS
    valueFrom: {fieldRef: {fieldPath: metadata.namespace}}
  - name: NODE_NAME
    valueFrom: {fieldRef: {fieldPath: spec.nodeName}}
  - name: MEM_LIMIT
    valueFrom:
      resourceFieldRef: {containerName: api, resource: limits.memory, divisor: 1Mi}

MEM_LIMIT va fi 512. Cu volume de tip downwardAPI, poți expune și etichetele și adnotările ca fișiere, care se actualizează când se schimbă etichetele (variabilele de mediu nu se actualizează).

Utilizări tipice: identificarea instanței în loguri, configurarea JVM-ului sau a pool-urilor după limite, etichetarea metricilor. Runtime-urile moderne (JVM 10+, .NET) detectează oricum limitele cgroup, dar Downward API e explicit și independent de limbaj.

Ce urmărește intervievatorul: Verifică cunoașterea unei unelte utile și evitarea drepturilor inutile. Mulți candidați propun să citească podul din API.

19 Mid

Ce este un container sidecar și ce s-a schimbat odată cu sidecar-urile native din Kubernetes 1.29?

Răspuns scurt: Un sidecar e un container ajutător care rulează lângă aplicație în același pod: proxy de rețea, colector de loguri, reîmprospătare de certificate. Sidecar-urile native sunt init containers cu restartPolicy: Always: pornesc înaintea aplicației, rulează toată viața podului și se opresc după ea.

Modelul clasic punea sidecar-ul ca al doilea container în containers. Problemele:

  • ordinea de pornire nu era garantată: aplicația putea porni înainte ca proxy-ul să fie gata;
  • la Joburi, podul nu se termina, pentru că sidecar-ul rula în continuare după ce jobul ieșea;
  • la oprire, sidecar-ul putea muri înaintea aplicației, care pierdea rețeaua în ultimele secunde.

Din Kubernetes 1.29 (beta, activat implicit; stabil din 1.33), declari sidecar-ul ca init container care nu se termină:

YAML
spec:
  initContainers:
  - name: loguri
    image: fluent/fluent-bit:3.1
    restartPolicy: Always
    volumeMounts: [{name: loguri, mountPath: /var/log/app}]
  containers:
  - name: api
    image: academia/api:1.0
    volumeMounts: [{name: loguri, mountPath: /var/log/app}]
  volumes:
  - name: loguri
    emptyDir: {}

Kubelet-ul îl pornește înaintea aplicației (și așteaptă startup probe-ul lui, dacă există), îl repornește dacă iese, nu îl ia în calcul la terminarea unui Job și îl oprește după containerele principale. Exemple reale: proxy-ul unui service mesh, agentul unui manager de secrete, cloud-sql-proxy.

Ce urmărește intervievatorul: Se verifică dacă ești la curent cu evoluția platformei și cu problemele practice ale sidecar-urilor. Greșeala tipică este să nu știi de problema joburilor care nu se termină.

Eroarea, în practică:Defaulted container out of

20 Mid

Ce se întâmplă, pas cu pas, când Kubernetes oprește un pod? Cum eviți erorile pentru cererile în curs?

Răspuns scurt: Podul e scos din endpoint-uri, rulează preStop, apoi containerele primesc SIGTERM și, după terminationGracePeriodSeconds (implicit 30 s), SIGKILL. Aplicația tratează SIGTERM, iar un preStop scurt acoperă întârzierea propagării endpoint-urilor.

La ștergere (rollout, scalare, drain), în paralel:

  • controllerul de endpoint-uri scoate podul din EndpointSlices, iar kube-proxy și controllerele de Ingress își actualizează regulile, cu o mică întârziere;
  • kubelet-ul rulează hook-ul preStop, dacă există, apoi trimite SIGTERM procesului principal (PID 1) din fiecare container;
  • după terminationGracePeriodSeconds (măsurat de la început, inclusiv preStop), trimite SIGKILL.

Problema: dacă aplicația se oprește imediat la SIGTERM, unele noduri încă trimit cereri spre ea, iar clienții primesc erori 502 sau conexiuni refuzate. Soluția tipică:

YAML
spec:
  terminationGracePeriodSeconds: 45
  containers:
  - name: api
    lifecycle:
      preStop:
        sleep: {seconds: 10}   # Kubernetes 1.30+; altfel exec: ["sh","-c","sleep 10"]

iar aplicația, la SIGTERM, nu mai acceptă conexiuni noi, termină cererile în curs, închide pool-urile și iese.

Capcane: un shell ca PID 1 (sh -c "java -jar app.jar") nu transmite SIGTERM procesului copil, deci folosește forma exec în command sau exec în script. Joburile lungi au nevoie de o perioadă de grație mai mare sau de puncte de reluare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să faci livrări fără erori pentru utilizatori. Mulți candidați nu știu de întârzierea dintre ștergere și scoaterea din endpoint-uri.

Eroarea, în practică:Readiness probe failed: connection refused

21 Mid

Un container are Last State: Terminated cu exit code 137, altul cu 143, altul cu 1. Ce înseamnă fiecare?

Răspuns scurt: 137 = 128 + 9: SIGKILL, de obicei OOMKilled sau perioada de grație expirată. 143 = 128 + 15: ieșire la SIGTERM, deci o oprire normală. 1 e o eroare a aplicației, explicată în jurnal.

Când un proces e oprit de un semnal, codul de ieșire raportat este 128 + numărul semnalului.

  • 137 (SIGKILL): dacă reason este OOMKilled, containerul a depășit limits.memory, iar kernelul l-a omorât. Soluția: mărești limita sau reduci consumul (heap JVM, cache, scurgeri de memorie). Dacă motivul e Error și se întâmplă la oprire, aplicația nu a terminat în terminationGracePeriodSeconds. Poate fi și o liveness probe care a eșuat și a dus la oprirea forțată după grație.
  • 143 (SIGTERM): aplicația a primit SIGTERM și a ieșit fără să trateze semnalul explicit. E normal la rollout sau scalare.
  • 1 (sau alt cod mic): aplicația a ieșit singură cu eroare: excepție netratată, configurare lipsă, port ocupat. Cauza e în kubectl logs --previous.
  • 0: ieșire cu succes. La un Deployment duce tot la CrashLoopBackOff, pentru că procesul nu trebuia să se termine.
  • 126 / 127: comanda nu se poate executa sau nu există (de obicei apare ca StartError).
BASH
kubectl get pod api -o jsonpath='{.status.containerStatuses[0].lastState.terminated}'

Pentru OOM, verifică și kubectl top pod și evenimentele nodului: dacă nodul a rămas fără memorie, podul poate fi evacuat, nu doar omorât.

Ce urmărește intervievatorul: Se verifică depanarea pe baza codurilor de ieșire. Greșeala tipică este să tratezi orice 137 ca problemă de memorie.

Eroarea, în practică:Back-off restarting failed containerOOMKilled (Exit Code 137)

22 Mid

Un pod stă în Pending de 10 minute. Cum găsești cauza și care sunt cauzele cele mai frecvente?

Răspuns scurt: kubectl describe pod arată evenimentul FailedScheduling cu motivul pentru fiecare grup de noduri. Cauze frecvente: requests prea mari, taint-uri netolerate, nodeSelector sau afinitate fără noduri potrivite, PVC nelegat. Dacă podul are nod, probabil imaginea încă se descarcă.

Pending înseamnă fie neprogramat, fie programat, dar cu containerele încă nepornite. Distincția se face din kubectl get pod -o wide (coloana NODE) și din evenimente.

Dacă nu are nod, mesajul scheduler-ului e explicit:

0/3 nodes are available: 1 node(s) had untolerated taint {node-role.kubernetes.io/control-plane: },
2 Insufficient memory. preemption: 0/3 nodes are available: ...

Cauze și verificări:

  • Resurse: suma requests de pe nod plus podul nou depășește capacitatea alocabilă. Compară cu kubectl describe node (Allocated resources). Reduci requests sau adaugi noduri (cluster autoscaler).
  • Taints: nodurile dedicate au taint-uri, iar podul nu are toleration.
  • nodeSelector / affinity: eticheta cerută nu există pe niciun nod (kubectl get nodes --show-labels).
  • Volume: pod has unbound immediate PersistentVolumeClaims sau disc într-o altă zonă.
  • topologySpreadConstraints / anti-affinity prea stricte pentru numărul de noduri.

Dacă are nod, dar e Pending: descărcarea imaginii (Pulling), ContainerCreating cu volume care nu se montează sau ConfigMap-uri lipsă. Dacă podul nici nu apare, verifică evenimentele ReplicaSet-ului: cotele sau un ServiceAccount lipsă blochează crearea.

Ce urmărește intervievatorul: Intervievatorul vrea un proces clar și cunoașterea cauzelor reale. Răspunsul slab este „mai adaug un nod”.

Eroarea, în practică:0/3 nodes are available: Insufficient cpu0/3 nodes are available: Insufficient memory

23 Senior

Cum depanezi un container pornit dintr-o imagine minimală (distroless), în care nu ai shell, curl sau ps?

Răspuns scurt: Folosești un container efemer cu kubectl debug: atașezi la pod un container cu unelte (busybox, netshoot), cu --target ca să vezi procesele aplicației. Alternativ, copiezi podul cu o imagine de depanare sau depanezi nodul cu kubectl debug node/....

Imaginile distroless sau scratch sunt mai mici și mai sigure, dar kubectl exec -it pod -- sh dă executable file not found. Din Kubernetes 1.25, containerele efemere sunt stabile:

BASH
kubectl debug -it pod/api-6f7c9d8b5-4kq2p --image=nicolaka/netshoot --target=api
  • Containerul nou e adăugat în podul existent, fără repornire, cu același IP și aceleași volume (dacă le montezi).
  • --target=api îl pune în namespace-ul de procese al containerului api, deci vezi procesul cu ps și fișierele lui prin /proc/1/root.
  • Containerele efemere nu au porturi, probe sau resurse și nu pot fi scoase; dispar odată cu podul.

Alte variante:

  • kubectl debug pod/api --copy-to=api-debug --set-image=api=academia/api:debug: o copie a podului cu altă imagine, util când containerul cade imediat.
  • kubectl debug node/worker-1 -it --image=busybox: un pod privilegiat pe nod, cu sistemul de fișiere al nodului în /host.

Atenție la securitate: dreptul de a crea containere efemere (pods/ephemeralcontainers) e practic acces la aplicație, deci în producție e restrâns prin RBAC și auditat. Păstrează imaginile minimale în producție; nu adăuga shell doar pentru depanare.

Ce urmărește intervievatorul: Se verifică experiența cu practicile moderne de securitate și depanare. Mulți candidați propun să reconstruiască imaginea cu shell.

Eroarea, în practică:cannot exec into a container in a completed pod

Deployment, Job, DaemonSet, StatefulSet

Exersează capitolul cu exerciții reale: Curs Kubernetes online →
24 Junior

Ce se întâmplă dacă ștergi un pod al unui Deployment? Dar dacă ștergi ReplicaSet-ul lui?

Răspuns scurt: Dacă ștergi podul, ReplicaSet-ul observă că are mai puține replici și creează imediat altul. Dacă ștergi ReplicaSet-ul curent, Deploymentul creează unul nou, identic, care pornește poduri noi, iar cele vechi sunt șterse în cascadă. Ca să oprești aplicația, scalezi sau ștergi Deploymentul.

Lanțul este Deployment → ReplicaSet → poduri, fiecare cu propriul controller.

BASH
kubectl delete pod magazin-7d9f8b6c5-x2kq9
kubectl get pods -l app=magazin     # apare un pod nou, cu alt sufix

ReplicaSet-ul are replicas: 3, vede 2 și creează al treilea. Asta e și metoda rapidă de a „reporni” un singur pod, dar pentru toate podurile se folosește kubectl rollout restart deployment/magazin, care respectă strategia de rolling update.

Dacă ștergi ReplicaSet-ul curent, ștergerea în cascadă elimină și podurile lui, iar controllerul de Deployment vede că nu mai există un ReplicaSet pentru șablonul curent și creează altul, cu același pod-template-hash. Rezultatul este o scurtă întrerupere, nu oprirea aplicației.

Întrebări de continuare frecvente:

  • Cum oprești temporar aplicația? kubectl scale deployment/magazin --replicas=0.
  • De ce rămân ReplicaSet-uri vechi cu 0 replici? Sunt istoricul pentru rollout undo, limitat de revisionHistoryLimit.
  • Ce se întâmplă dacă editezi direct ReplicaSet-ul? Deploymentul îl readuce la starea din șablon la următoarea reconciliere.

Ce urmărește intervievatorul: Verifică înțelegerea ierarhiei de controllere. Greșeala tipică este să ștergi podurile ca să oprești o aplicație.

25 Junior

Care e diferența dintre un Job și un CronJob? Ce fac completions și parallelism?

Răspuns scurt: Un Job rulează poduri până când un număr dat se termină cu succes. Un CronJob creează Joburi după un program cron. completions e numărul de terminări reușite necesare, iar parallelism e câte poduri rulează simultan.

Un Job e pentru sarcini care trebuie să se termine: un import, un raport, o migrare. Controllerul creează poduri, le reîncearcă la eșec (până la backoffLimit) și marchează Jobul Complete sau Failed.

YAML
apiVersion: batch/v1
kind: Job
metadata: {name: redimensionare}
spec:
  completions: 10
  parallelism: 3
  backoffLimit: 4
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: worker
        image: academia/raport:1.0

Aici sunt necesare 10 rulări reușite, cel mult 3 simultan. Cu completionMode: Indexed, fiecare pod primește un index (JOB_COMPLETION_INDEX), util când fiecare prelucrează altă bucată de date. Fără completions, un Job cu parallelism > 1 funcționează ca o coadă de lucru: se termină când un pod termină cu succes, iar restul se opresc.

Un CronJob are un jobTemplate și un schedule ("0 2 * * *"). La fiecare moment programat creează un Job nou. Setări importante: concurrencyPolicy (Allow, Forbid, Replace), successfulJobsHistoryLimit, failedJobsHistoryLimit și timeZone. Testezi manual cu kubectl create job test --from=cronjob/raport.

Ce urmărește intervievatorul: Se verifică alegerea corectă a obiectului pentru sarcini finite. Mulți candidați nu știu de parallelism și completions.

Eroarea, în practică:Job spec.template: field is immutable

26 Junior

Ce este un DaemonSet și pentru ce fel de aplicații îl folosești?

Răspuns scurt: Un DaemonSet rulează câte un pod pe fiecare nod (sau pe nodurile selectate) și adaugă automat poduri pe nodurile noi. Îl folosești pentru agenți de nod: colectoare de loguri, exportere de metrici, pluginuri de rețea sau de stocare.

Spre deosebire de un Deployment, unde alegi numărul de replici, la un DaemonSet numărul e dat de noduri. Când adaugi un nod, primește automat podul; când scoți un nod, podul dispare odată cu el.

Exemple reale: Fluent Bit sau Vector pentru loguri, node-exporter pentru metricile nodului, kube-proxy, pluginurile CNI (Calico, Cilium) și driverele CSI.

YAML
apiVersion: apps/v1
kind: DaemonSet
metadata: {name: loguri}
spec:
  selector: {matchLabels: {app: loguri}}
  template:
    metadata: {labels: {app: loguri}}
    spec:
      tolerations:
      - key: node-role.kubernetes.io/control-plane
        effect: NoSchedule
      containers:
      - name: fluent-bit
        image: fluent/fluent-bit:3.1
        volumeMounts: [{name: varlog, mountPath: /var/log, readOnly: true}]
      volumes:
      - name: varlog
        hostPath: {path: /var/log}

Detalii utile: fără toleration, podul nu ajunge pe nodurile control plane, care au taint. Cu nodeSelector sau afinitate îl limitezi la anumite noduri (de exemplu cele cu GPU). Actualizarea se face cu updateStrategy: RollingUpdate și maxUnavailable, nod cu nod. kubectl drain are nevoie de --ignore-daemonsets, pentru că aceste poduri ar fi recreate imediat pe același nod.

Ce urmărește intervievatorul: Se verifică dacă alegi obiectul potrivit pentru sarcini legate de noduri. Greșeala tipică este un Deployment cu atâtea replici câte noduri sunt.

Eroarea, în practică:cannot delete DaemonSet-managed Pods

27 Junior

Ai un Deployment gestionat prin fișiere YAML în git și un HPA atașat. De ce e o problemă dacă fișierul conține replicas: 3?

Răspuns scurt: La fiecare kubectl apply, fișierul readuce replicas la 3, peste valoarea calculată de HPA, deci aplicația scade brusc la 3 poduri, iar HPA-ul o crește din nou. Când folosești HPA, scoți replicas din manifest și lași HPA-ul să o gestioneze.

HPA-ul scrie spec.replicas prin subresursa scale. Dacă manifestul din git conține și el replicas: 3, fiecare kubectl apply (sau sincronizare GitOps) suprascrie valoarea curentă. Scenariu: la ora de vârf HPA-ul a urcat la 9 replici, cineva livrează o schimbare de configurare, iar apply-ul coboară la 3. Șase poduri sunt oprite în plină încărcare, apoi HPA-ul le recreează după câteva zeci de secunde.

Soluții:

  • scoți replicas din manifest când Deploymentul are HPA; la creare, valoarea implicită e 1, iar HPA-ul o ridică la minReplicas;
  • în Helm, multe charturi pun {{- if not .Values.autoscaling.enabled }} în jurul câmpului, exact din acest motiv;
  • în Argo CD, câmpul poate fi ignorat la comparație (ignoreDifferences).

La fel se întâmplă cu kubectl scale manual: valoarea e suprascrisă de HPA la următorul calcul, deci scalarea manuală nu are efect durabil când există HPA.

În general, un câmp trebuie să aibă un singur proprietar. Server-side apply face asta explicit prin managedFields și semnalează conflictele.

Ce urmărește intervievatorul: Intervievatorul verifică experiența cu interacțiunea dintre GitOps și autoscalare. Problema apare des în producție și puțini candidați o anticipează.

28 Junior

Un Deployment are 4 replici, maxSurge: 1 și maxUnavailable: 0. Descrie cum decurge rolling update-ul și cât durează minim.

Răspuns scurt: Kubernetes creează un pod nou (5 în total), așteaptă să fie Ready, apoi oprește unul vechi și repetă de patru ori. Capacitatea nu scade niciodată sub 4, dar actualizarea durează cel puțin de patru ori timpul de pornire până la Ready (plus minReadySeconds).

maxSurge spune câte poduri pot exista peste numărul dorit, iar maxUnavailable, câte pot lipsi din cele disponibile. Pot fi numere sau procente (implicit 25% și 25%, rotunjite în sus pentru surge și în jos pentru unavailable).

Cu 4 replici, surge 1, unavailable 0:

  • pasul 1: ReplicaSet-ul nou primește 1 pod, deci sunt 5 poduri; se așteaptă ca podul nou să devină Ready (readiness probe) și să rămână așa minReadySeconds;
  • pasul 2: ReplicaSet-ul vechi scade la 3; apoi încă un pod nou, și tot așa;
  • după 4 cicluri, vechiul ReplicaSet are 0, iar cel nou 4.

Dacă un pod nou nu devine niciodată Ready (imagine greșită, crash), rollout-ul se oprește după primul pas: rămân 4 poduri vechi funcționale și 1 nou stricat, iar după progressDeadlineSeconds Deploymentul raportează ProgressDeadlineExceeded. De aceea maxUnavailable: 0 plus readiness probe e combinația sigură.

Varianta maxSurge: 0, maxUnavailable: 1 nu cere resurse în plus (util când clusterul sau cota sunt pline), dar scade capacitatea temporar la 3. Valori mai mari pentru surge accelerează rollout-ul, cu prețul a mai multe resurse ocupate simultan.

BASH
kubectl rollout status deployment/magazin

Ce urmărește intervievatorul: Se verifică înțelegerea concretă a parametrilor, nu doar definiția rolling update-ului. Mulți nu știu că un pod nou stricat oprește rollout-ul fără să afecteze podurile vechi.

Eroarea, în practică:deployment exceeded its progress deadline

29 Junior

Când alegi strategia Recreate în locul RollingUpdate?

Răspuns scurt: Când două versiuni nu pot rula simultan: schemă de date incompatibilă, volum ReadWriteOnce montat de un singur pod, aplicație care trebuie să fie unică. Recreate oprește toate podurile vechi, apoi le pornește pe cele noi, cu o scurtă întrerupere.

Cu RollingUpdate (implicit), versiunea veche și cea nouă coexistă câteva secunde sau minute. De obicei e exact ce vrei, dar uneori nu e posibil:

  • Volum RWO: un singur pod (pe un nod) are volumul atașat. Podul nou ar rămâne în ContainerCreating cu Multi-Attach error cât timp cel vechi încă rulează pe alt nod.
  • Migrări incompatibile: versiunea nouă schimbă structura datelor într-un fel pe care cea veche nu-l înțelege.
  • Singleton: un consumator care nu trebuie dublat, un proces cu lock exclusiv, o aplicație veche care nu suportă mai multe instanțe.
YAML
spec:
  strategy:
    type: Recreate

Prețul e o întrerupere egală cu timpul de oprire plus timpul de pornire al versiunii noi. Dacă versiunea nouă nu pornește, aplicația rămâne oprită până la rollback.

Alternative: pentru volume, un StatefulSet cu un singur pod (maxUnavailable implicit 1) sau un volum RWX; pentru baze de date, migrări compatibile înapoi (expand și contract), ca rolling update-ul să rămână posibil.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi compromisurile strategiilor. Răspunsul slab este „Recreate e mai simplu”, fără să pomenești întreruperea.

30 Junior

Cum vezi istoricul unui Deployment și cum revii la o versiune anterioară? Ce face revisionHistoryLimit?

Răspuns scurt: kubectl rollout history arată reviziile (cu motivul din adnotarea kubernetes.io/change-cause), --revision=N arată detaliile uneia, iar kubectl rollout undo revine la precedenta sau, cu --to-revision, la una anume. revisionHistoryLimit (implicit 10) spune câte ReplicaSet-uri vechi se păstrează pentru rollback.

Fiecare schimbare a șablonului podului (imagine, variabile, resurse, etichete ale podului) creează un ReplicaSet nou și o revizie nouă. Scalarea nu creează revizie.

BASH
kubectl annotate deployment/magazin kubernetes.io/change-cause="v2: plăți cu cardul"
kubectl rollout history deployment/magazin
kubectl rollout history deployment/magazin --revision=2
kubectl rollout undo deployment/magazin
kubectl rollout undo deployment/magazin --to-revision=1

Detalii care apar la interviu:

  • un undo nu „întoarce timpul”: copiază șablonul vechi și creează o revizie nouă, iar numărul vechi dispare din istoric;
  • revisionHistoryLimit controlează câte ReplicaSet-uri cu 0 replici rămân; cu 0, nu mai poți face rollback;
  • rollback-ul revine doar la șablonul podului, nu și la ConfigMap-urile sau Secret-urile referite, care pot fi între timp modificate. De aceea configurațiile versionate (setari-v2) sau generate cu hash se potrivesc bine cu rollback-ul.

În echipele cu GitOps, rollback-ul preferat e un git revert: altfel, următoarea sincronizare readuce versiunea din git și anulează rollout undo.

Ce urmărește intervievatorul: Se verifică operarea de zi cu zi. Greșeala tipică este să crezi că rollback-ul restaurează și configurația externă.

Eroarea, în practică:unable to find specified revision in history

31 Mid

Un CronJob care rulează la fiecare 5 minute pornește uneori a doua instanță înainte ca prima să termine. Ce setări folosești?

Răspuns scurt: concurrencyPolicy: Forbid sare peste rularea nouă cât timp cea veche rulează; Replace o oprește pe cea veche și pornește una nouă. Pui și activeDeadlineSeconds pe Job, ca o rulare blocată să nu țină pe loc toate rulările viitoare, plus startingDeadlineSeconds pentru rulările întârziate.

Implicit (concurrencyPolicy: Allow), CronJob-ul creează un Job nou la fiecare moment programat, indiferent dacă cel anterior s-a terminat. Pentru o sarcină care scrie în aceleași date (sincronizare, facturare), două instanțe simultane pot produce dubluri.

YAML
apiVersion: batch/v1
kind: CronJob
metadata: {name: sincronizare}
spec:
  schedule: "*/5 * * * *"
  timeZone: Europe/Bucharest
  concurrencyPolicy: Forbid
  startingDeadlineSeconds: 120
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      activeDeadlineSeconds: 240
      backoffLimit: 2
      template:
        spec:
          restartPolicy: Never
          containers:
          - name: sync
            image: academia/raport:1.0
  • Forbid: rularea suprapusă e sărită.
  • Replace: rularea veche e oprită și înlocuită.
  • activeDeadlineSeconds: 240: o rulare nu poate depăși 4 minute, deci nu blochează ciclul următor.
  • startingDeadlineSeconds: dacă controllerul a ratat momentul (de exemplu a fost indisponibil), rularea se mai face doar în această fereastră.

Atenție: Kubernetes garantează „cel puțin o dată” în condiții normale, dar în cazuri rare poate crea două Joburi pentru același moment sau niciunul. Sarcina trebuie să fie idempotentă sau să folosească un lock.

Ce urmărește intervievatorul: Intervievatorul verifică experiența cu sarcinile programate din producție. Mulți candidați nu știu de garanțiile slabe ale CronJob-urilor.

32 Mid

Ce fac backoffLimit, activeDeadlineSeconds, ttlSecondsAfterFinished și podFailurePolicy la un Job?

Răspuns scurt: backoffLimit limitează numărul de eșecuri (implicit 6), activeDeadlineSeconds limitează durata totală, ttlSecondsAfterFinished șterge Jobul terminat după un timp, iar podFailurePolicy decide după exit code sau condiții dacă un eșec se numără, se ignoră sau oprește imediat Jobul.

Exemplu complet:

YAML
apiVersion: batch/v1
kind: Job
metadata: {name: import-produse}
spec:
  backoffLimit: 3
  activeDeadlineSeconds: 900
  ttlSecondsAfterFinished: 3600
  podFailurePolicy:
    rules:
    - action: FailJob
      onExitCodes: {containerName: import, operator: In, values: [42]}
    - action: Ignore
      onPodConditions: [{type: DisruptionTarget}]
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: import
        image: academia/raport:1.0
  • backoffLimit: după 3 eșecuri, Jobul devine Failed cu motivul BackoffLimitExceeded. Între încercări există backoff exponențial (10 s, 20 s, 40 s...).
  • activeDeadlineSeconds: după 15 minute de la pornire, toate podurile sunt oprite și Jobul eșuează cu DeadlineExceeded, oricâte încercări ar mai avea.
  • ttlSecondsAfterFinished: Jobul și podurile lui sunt șterse automat la o oră după terminare, deci nu se adună mii de Joburi vechi.
  • podFailurePolicy (stabil din 1.31, cere restartPolicy: Never): codul 42, folosit de aplicație pentru „date invalide”, oprește imediat Jobul, pentru că reîncercarea nu ar ajuta; podurile evacuate (de exemplu la drain) nu se numără ca eșecuri.

Așa separi erorile permanente de cele temporare și eviți reîncercări inutile.

Ce urmărește intervievatorul: Se verifică dacă poți face joburi robuste în producție. Puțini candidați cunosc podFailurePolicy și diferența dintre limita de încercări și cea de timp.

Eroarea, în practică:Job has reached the specified backoff limitJob was active longer than specified deadline

33 Mid

Ce garanții oferă un StatefulSet față de un Deployment în privința identității și ordinii podurilor? Ce face podManagementPolicy: Parallel?

Răspuns scurt: Podurile unui StatefulSet au nume stabile (db-0, db-1), un nume DNS propriu prin serviciul headless și volumul lor propriu, păstrat la recreare. Implicit pornesc și se opresc pe rând, în ordine. Parallel renunță la ordinea de creare și ștergere, dar păstrează identitatea.

Un Deployment tratează podurile ca interschimbabile: nume aleatorii, fără ordine, fără disc propriu. Un StatefulSet dă fiecăruia o identitate:

  • nume ordinal stabil: db-0, db-1, db-2; dacă db-1 e recreat, se numește tot db-1;
  • DNS stabil prin serviciul headless din serviceName: db-1.db.magazin.svc.cluster.local, deci un client sau o replică știe exact pe cine apelează;
  • volum propriu din volumeClaimTemplates: date-db-1 rămâne legat de db-1, chiar dacă podul se mută pe alt nod.

Ordinea implicită (OrderedReady): la creare, db-1 pornește doar după ce db-0 e Ready; la scalare în jos, se șterge întâi indexul cel mai mare. La rolling update, podurile sunt actualizate de la cel mai mare index spre 0, câte unul, iar cu partition: 2 actualizezi doar indexurile mai mari sau egale cu 2 (canary manual).

podManagementPolicy: Parallel pornește și oprește toate podurile simultan. E util pentru sisteme care își gestionează singure rolurile (de exemplu clustere cu consens care pornesc mai repede împreună), unde ordinea strictă doar încetinește.

Ce nu face StatefulSet-ul: replicarea datelor, alegerea unui lider sau backup-ul. Acelea sunt treaba aplicației sau a unui operator.

Ce urmărește intervievatorul: Intervievatorul verifică înțelegerea precisă a garanțiilor. Greșeala tipică este să crezi că StatefulSet-ul replică singur datele între poduri.

34 Mid

Unde e problema în acest manifest? kubectl apply îl refuză.

YAML
apiVersion: apps/v1
kind: Deployment
metadata:
  name: catalog
spec:
  replicas: 2
  selector:
    matchLabels:
      app: catalog
  template:
    metadata:
      labels:
        app: catalog-api
    spec:
      containers:
      - name: catalog
        image: academia/api:1.0
        ports:
        - containerPort: "3000"

Răspuns scurt: Două probleme: selectorul cere app=catalog, dar șablonul podului are app=catalog-api, deci Deploymentul nu și-ar recunoaște podurile (eroarea selector does not match template labels). Iar containerPort e text între ghilimele, nu număr, ceea ce dă o eroare de tip.

Selectorul unui Deployment trebuie să se potrivească cu etichetele din template.metadata.labels. Altfel, ReplicaSet-ul ar crea poduri pe care nu le-ar număra ca fiind ale lui și ar crea la nesfârșit altele. API server-ul refuză obiectul:

The Deployment "catalog" is invalid: spec.template.metadata.labels: Invalid value:
map[string]string{"app":"catalog-api"}: `selector` does not match template `labels`

Corectura: aceeași etichetă în ambele locuri (app: catalog). Șablonul poate avea etichete în plus (version: v1), dar trebuie să le conțină pe toate din selector. Reține și că spec.selector e imutabil după creare: dacă vrei alt selector, recreezi Deploymentul.

containerPort e de tip int32. "3000" între ghilimele e un string, iar decodarea dă:

json: cannot unmarshal string into Go struct field ContainerPort.spec.template.spec.containers.ports.containerPort of type int32

Versiunea corectă:

YAML
  template:
    metadata:
      labels:
        app: catalog
    spec:
      containers:
      - name: catalog
        image: academia/api:1.0
        ports:
        - containerPort: 3000

Asemenea greșeli le prinzi înainte de livrare cu kubectl apply --dry-run=server -f sau cu kubeconform în pipeline.

Ce urmărește intervievatorul: Se verifică atenția la detalii în YAML și cunoașterea legăturii selector-etichete. Mulți observă doar una dintre cele două erori.

Eroarea, în practică:`selector` does not match template `labels`spec.selector: Required value

35 Mid

Ce este un PodDisruptionBudget și ce protejează (și ce nu)?

Răspuns scurt: Un PDB limitează câte poduri ale unei aplicații pot fi oprite simultan prin evacuări voluntare (kubectl drain, upgrade de noduri, cluster autoscaler), cu minAvailable sau maxUnavailable. Nu protejează la căderea unui nod, la OOM sau la ștergerea directă a podurilor ori la rollout-ul Deploymentului.

Mentenanța nodurilor folosește Eviction API: kubectl drain cere evacuarea fiecărui pod, iar API server-ul verifică PDB-urile. Dacă evacuarea ar încălca bugetul, cererea e refuzată (429) și drain-ul reîncearcă până când alt pod devine disponibil.

YAML
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata: {name: api}
spec:
  minAvailable: 2
  selector:
    matchLabels: {app: api}

Cu 3 replici și minAvailable: 2, drain-ul poate lua un singur pod odată; după ce Deploymentul îl recreează pe alt nod și devine Ready, poate continua.

Ce nu acoperă un PDB:

  • întreruperi involuntare: un nod care moare, kernel panic, OOM;
  • kubectl delete pod direct și ștergerea Deploymentului;
  • rolling update-ul, care e controlat de maxUnavailable din Deployment.

Capcane: un PDB cu minAvailable egal cu numărul de replici (sau maxUnavailable: 0) blochează orice drain și deci upgrade-urile de cluster. Cu o singură replică, PDB-ul nu poate garanta disponibilitate, ci doar blochează mentenanța. Recomandarea: cel puțin 2 replici, poduri răspândite pe noduri și maxUnavailable: 1.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să faci aplicația să supraviețuiască mentenanței. Greșeala tipică este să crezi că PDB-ul protejează de orice întrerupere.

Eroarea, în practică:Cannot evict pod: would violate disruption budget

36 Mid

Aplicația ta pornește înaintea bazei de date și intră în CrashLoopBackOff câteva minute la fiecare instalare. Cum rezolvi corect?

Răspuns scurt: Aplicația trebuie să reîncerce conexiunea la bază de date cu backoff, nu să iasă la prima eroare, iar readiness probe-ul o ține în afara traficului până e conectată. Un init container care așteaptă baza de date ajută la pornire, dar nu înlocuiește reîncercările.

Kubernetes nu are ordonare între Deploymenturi diferite, iar asta e intenționat: într-un sistem distribuit, dependențele pot cădea oricând, nu doar la pornire. Dacă aplicația iese când baza de date nu răspunde, ciclul de reporniri (cu backoff până la 5 minute) poate întârzia pornirea mult după ce baza de date e gata.

Soluția robustă are trei părți:

  • reîncercare în aplicație: conexiunea se reîncearcă cu backoff (pool-urile JDBC, pg-pool, SQLAlchemy au opțiuni pentru asta), iar aplicația nu iese din cauza unei dependențe indisponibile;
  • readiness probe care reflectă capacitatea de a servi cereri, ca podul să nu primească trafic până nu e pregătit; liveness probe-ul nu verifică baza de date, altfel o problemă a ei ar reporni toate podurile;
  • opțional, un init container care așteaptă ca baza de date să răspundă, pentru o pornire mai curată:
YAML
initContainers:
- name: asteapta-db
  image: postgres:16
  command: ["sh", "-c", "until pg_isready -h postgres -p 5432; do sleep 2; done"]

Pentru migrări de schemă, un Job separat (sau un hook Helm pre-upgrade) e mai sigur decât migrarea pornită de fiecare replică. Explicația asta arată că înțelegi de ce „depends_on” din Compose nu are echivalent direct.

Ce urmărește intervievatorul: Se verifică gândirea despre sisteme distribuite. Răspunsul slab caută o ordine de pornire garantată între servicii.

Eroarea, în practică:Init:0/1: podul rămâne în init container

37 Senior

Cum ai face o livrare canary doar cu obiecte native Kubernetes și ce limite are abordarea?

Răspuns scurt: Două Deploymenturi cu aceeași etichetă folosită de Service (de exemplu 9 replici stabile și 1 canary) primesc trafic aproximativ proporțional cu numărul de poduri. E simplu, dar procentul depinde de replici, nu poate ruta după utilizator și nu are analiză automată sau rollback.

Varianta nativă:

YAML
# Deployment magazin-stabil: replicas 9, etichete app=magazin, track=stabil, imagine v1
# Deployment magazin-canary: replicas 1, etichete app=magazin, track=canary, imagine v2
apiVersion: v1
kind: Service
metadata: {name: magazin}
spec:
  selector: {app: magazin}
  ports: [{port: 80, targetPort: 8080}]

Serviciul alege ambele grupuri, deci aproximativ 10% din conexiuni ajung la v2. Urmărești erorile și latența etichetate cu track, apoi crești canary-ul și scazi versiunea stabilă, sau ștergi canary-ul la probleme.

Limite:

  • procentul e legat de numărul de poduri: 1% cere 100 de replici;
  • distribuția e pe conexiuni, nu pe cereri; cu conexiuni persistente (HTTP/2, gRPC) poate fi foarte inegală;
  • nu poți trimite la canary doar angajații sau o anumită regiune;
  • decizia și rollback-ul sunt manuale.

Alternative: ingress-nginx cu adnotările canary-weight sau canary-by-header, Gateway API cu HTTPRoute și ponderi, un service mesh (Istio, Linkerd) sau Argo Rollouts și Flagger, care fac și analiză automată pe metrici și rollback. Pentru discuția despre strategii în general (blue-green, canary), legătura cu pipeline-ul e la fel de importantă ca mecanismul.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi mecanismul serviciilor și limitele lui. Un candidat bun pomenește distribuția pe conexiuni.

Services, DNS și Ingress

38 Junior

Cum găsește un pod un serviciu după nume? Ce înseamnă api, api.plati și api.plati.svc.cluster.local?

Răspuns scurt: CoreDNS rezolvă numele serviciilor în ClusterIP. Fișierul /etc/resolv.conf al podului are domenii de căutare, deci api se caută întâi în namespace-ul podului, api.plati în namespace-ul plati, iar numele complet (FQDN) funcționează de oriunde.

Fiecare Service primește o înregistrare DNS NUME.NAMESPACE.svc.cluster.local (domeniul clusterului poate diferi, dar cluster.local e cel implicit). Kubelet-ul scrie în pod:

nameserver 10.96.0.10
search magazin.svc.cluster.local svc.cluster.local cluster.local
options ndots:5

Pentru un pod din magazin:

  • api → încearcă api.magazin.svc.cluster.local (serviciul din același namespace);
  • api.plati → api.plati.svc.cluster.local după al doilea domeniu de căutare;
  • api.plati.svc.cluster.local → numele complet, fără căutare.

Detaliu de performanță: cu ndots:5, un nume cu mai puțin de 5 puncte, de exemplu api.github.com, e încercat întâi cu toate domeniile de căutare, deci 3-4 interogări eșuate înainte de cea bună. Pentru aplicații care apelează mult nume externe, poți scrie numele cu punct final (api.github.com.) sau poți ajusta dnsConfig în pod.

Verificare din cluster:

BASH
kubectl run dns --rm -it --image=busybox:1.36 --restart=Never -- nslookup api.plati

Podurile simple nu primesc nume DNS după numele lor; doar serviciile (și podurile din StatefulSet-uri, prin serviciul headless).

Ce urmărește intervievatorul: Se verifică înțelegerea DNS-ului din cluster. Greșeala tipică este să apelezi un serviciu din alt namespace doar cu numele scurt.

Eroarea, în practică:wget: bad addressserver can't find ...: NXDOMAIN

39 Junior

Explică diferența dintre containerPort, targetPort, port și nodePort cu un exemplu.

Răspuns scurt: containerPort documentează portul pe care ascultă containerul. targetPort e portul podului spre care trimite serviciul. port e portul serviciului în cluster (ClusterIP:port). nodePort e portul deschis pe fiecare nod, între 30000 și 32767, pentru serviciile NodePort.

Exemplu: aplicația ascultă pe 8080.

YAML
# în pod
ports:
- name: http
  containerPort: 8080
---
apiVersion: v1
kind: Service
metadata: {name: magazin}
spec:
  type: NodePort
  selector: {app: magazin}
  ports:
  - port: 80          # clienții din cluster: http://magazin:80
    targetPort: http  # sau 8080: portul podului
    nodePort: 30080   # din exterior: http://IP-NOD:30080

Drumul unei cereri: din exterior la IP-NOD:30080, apoi kube-proxy trimite către un pod la IP-POD:8080. Din cluster, magazin:80 ajunge la același IP-POD:8080.

Detalii importante:

  • containerPort e în mare parte informativ: aplicația ascultă pe portul ei oricum, chiar dacă nu e declarat. Dar declararea cu nume permite targetPort: http, care rămâne corect dacă portul aplicației se schimbă.
  • Dacă lipsește, targetPort are valoarea lui port. O sursă clasică de Connection refused e un serviciu cu port: 80 fără targetPort, pentru o aplicație care ascultă pe 8080.
  • nodePort se alege automat dacă nu-l dai, iar dacă îl dai trebuie să fie liber în tot clusterul.

Ce urmărește intervievatorul: Intervievatorul verifică o confuzie foarte frecventă. Un candidat bun explică drumul complet al cererii.

Eroarea, în practică:cannot unmarshal string into ... of type int32can't connect to remote host: Connection refused

40 Junior

Cum verifici că un Service are poduri în spate? Ce sunt Endpoints și EndpointSlices?

Răspuns scurt: kubectl get endpoints NUME (sau kubectl get endpointslices -l kubernetes.io/service-name=NUME) arată IP-urile și porturile podurilor Ready alese de selectorul serviciului. Dacă lista e goală, selectorul nu se potrivește sau podurile nu sunt Ready.

Controllerul de endpoint-uri urmărește podurile care se potrivesc cu selectorul serviciului și le pune pe cele Ready în obiecte EndpointSlice (împărțite în bucăți de până la 100 de adrese implicit, ca actualizările să fie mici). Obiectul mai vechi Endpoints conține toate adresele într-un singur obiect și e păstrat pentru compatibilitate (din 1.33 e marcat ca depreciat în favoarea EndpointSlice).

BASH
kubectl get endpoints magazin
kubectl get endpointslices -l kubernetes.io/service-name=magazin -o wide
kubectl describe svc magazin | grep -E 'Selector|Endpoints'

Cazuri:

  • <none>: compară selectorul cu kubectl get pods --show-labels. Greșeli tipice: app: magazin-web față de app: magazin, sau serviciu creat cu kubectl create service, care pune selectorul app=NUMESERVICIU.
  • Adrese doar în notReadyAddresses: podurile există, dar readiness probe-ul pică.
  • Adrese prezente, dar conexiunea eșuează: targetPort greșit sau aplicația ascultă doar pe 127.0.0.1.

Un serviciu fără selector nu primește endpoint-uri automat: le creezi tu, de exemplu pentru o bază de date din afara clusterului, care devine astfel accesibilă printr-un nume intern.

Ce urmărește intervievatorul: Se verifică primul pas în depanarea rețelei. Mulți candidați nu știu că doar podurile Ready apar în endpoint-uri.

Eroarea, în practică:Readiness probe failed: statuscode: 404Service fără endpoint-uri (Endpoints: <none>)

41 Junior

Ce este un serviciu headless și când îl folosești?

Răspuns scurt: Un serviciu cu clusterIP: None nu primește IP virtual: DNS-ul întoarce direct IP-urile podurilor, iar fiecare pod al unui StatefulSet primește un nume propriu. Îl folosești la StatefulSet-uri (replici de baze de date, clustere cu consens) și când clientul vrea să aleagă singur podul.

Un serviciu obișnuit (ClusterIP) are o adresă virtuală, iar kube-proxy distribuie conexiunile între poduri. Clientul nu știe și nu alege cu ce pod vorbește.

Un serviciu headless:

YAML
apiVersion: v1
kind: Service
metadata: {name: db}
spec:
  clusterIP: None
  selector: {app: db}
  ports: [{port: 5432}]
  • nslookup db întoarce câte o înregistrare A pentru fiecare pod Ready;
  • cu un StatefulSet care are serviceName: db, fiecare pod primește db-0.db.NAMESPACE.svc.cluster.local, db-1.db..., deci replica 1 se poate conecta explicit la primarul db-0;
  • nu trece prin kube-proxy, deci nu există load balancing la nivel de serviciu.

Cazuri de utilizare: bazele de date cu replicare (Postgres, MongoDB), sisteme ca Kafka, ZooKeeper, etcd sau Elasticsearch, unde membrii trebuie să se găsească unul pe altul, și clienți gRPC care fac singuri load balancing pe baza tuturor adreselor.

Cu publishNotReadyAddresses: true, DNS-ul include și podurile care nu sunt încă Ready, util la pornirea unui cluster în care membrii trebuie să se descopere înainte să fie gata.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi diferența dintre load balancing și descoperire. Greșeala tipică este să crezi că headless înseamnă „serviciu fără selector”.

42 Junior

La ce folosește un serviciu de tip ExternalName? Dă un exemplu.

Răspuns scurt: ExternalName creează un alias DNS (CNAME) către un nume din afara clusterului. Aplicația folosește un nume intern stabil, de exemplu db, iar tu schimbi destinația (o bază de date gestionată în cloud) fără să modifici configurația aplicației.

YAML
apiVersion: v1
kind: Service
metadata: {name: db, namespace: magazin}
spec:
  type: ExternalName
  externalName: magazin-prod.abc123.eu-central-1.rds.amazonaws.com

Podurile din magazin se conectează la db:5432; CoreDNS răspunde cu un CNAME către numele RDS. Avantaje: aceeași configurație a aplicației în toate mediile (în dev, db poate fi un serviciu intern cu un Postgres din cluster) și o migrare ulterioară a bazei de date în cluster fără schimbări în aplicație.

Limite importante:

  • e doar DNS: nu are porturi, endpoint-uri sau load balancing, iar kube-proxy nu e implicat;
  • HTTP și TLS: clientul trimite antetul Host și SNI cu numele db, nu cu numele real. Multe servicii HTTPS externe vor răspunde cu eroare de certificat sau 404. Funcționează bine pentru protocoale care nu verifică numele (Postgres, MySQL, Redis fără TLS) sau dacă clientul configurează explicit numele pentru TLS;
  • externalName trebuie să fie un nume DNS, nu o adresă IP.

Pentru o adresă IP externă, varianta corectă este un serviciu fără selector plus un EndpointSlice creat manual cu acel IP.

Ce urmărește intervievatorul: Se verifică cunoașterea tipurilor de servicii mai rare și a limitelor lor. Puțini candidați știu de problema cu TLS și Host.

43 Junior

Care sunt variantele prin care ajungi din afara clusterului la o aplicație și când o alegi pe fiecare?

Răspuns scurt: port-forward pentru depanare locală; NodePort pentru teste și medii simple; LoadBalancer pentru un IP extern, util și la protocoale non-HTTP; Ingress sau Gateway API pentru aplicații HTTP(S), cu mai multe hosturi și TLS în spatele unei singure intrări.

  • port-forward: kubectl port-forward svc/magazin 8080:80 deschide un tunel prin API server, doar pe calculatorul tău și doar cât rulează comanda. Perfect pentru depanare și acces temporar la o bază de date. Nu e pentru utilizatori.
  • NodePort: deschide un port din intervalul 30000-32767 pe toate nodurile. Simplu, dar porturile sunt incomode, iar clientul trebuie să știe IP-urile nodurilor, care se pot schimba. Folosit în laboratoare sau în spatele unui load balancer extern configurat manual.
  • LoadBalancer: în cloud, Kubernetes cere furnizorului un load balancer cu IP public (sau privat). Un IP pentru fiecare serviciu, deci costă când sunt multe servicii. Potrivit pentru TCP sau UDP non-HTTP (baze de date expuse intern, MQTT, gRPC fără Ingress). On-premise, ai nevoie de MetalLB sau ceva similar.
  • Ingress / Gateway API: un singur punct de intrare HTTP(S), de obicei el însuși un serviciu LoadBalancer, care rutează după host și cale către multe servicii interne, cu TLS centralizat. Varianta standard pentru aplicații web.

Pentru acces doar din rețeaua companiei, se folosesc load balancere interne (adnotări specifice cloud-ului) sau un VPN, nu NodePort expus public.

Ce urmărește intervievatorul: Intervievatorul verifică dacă alegi mecanismul după nevoie. Greșeala tipică este un LoadBalancer separat pentru fiecare microserviciu HTTP.

Eroarea, în practică:nodePort: provided port is not in the valid rangenodePort: provided port is already allocated

44 Mid

Scrie un Ingress care trimite magazin.ro/api la serviciul api și restul la frontend. Ce rol au pathType și ingressClassName?

Răspuns scurt: Un Ingress cu host magazin.ro și două căi Prefix: /api către api:80 și / către frontend:80. pathType Prefix potrivește calea și subcăile ei, iar Exact doar calea exactă. ingressClassName alege controllerul care aplică regula.

YAML
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: magazin
spec:
  ingressClassName: nginx
  rules:
  - host: magazin.ro
    http:
      paths:
      - path: /api
        pathType: Prefix
        backend:
          service: {name: api, port: {number: 80}}
      - path: /
        pathType: Prefix
        backend:
          service: {name: frontend, port: {number: 80}}

Cum se aleg regulile: când mai multe căi se potrivesc, câștigă cea mai lungă, deci /api/produse ajunge la api, iar /cos la frontend. Prefix se potrivește pe segmente: /api include /api/x, dar nu /apix. Exact potrivește doar /api. ImplementationSpecific lasă interpretarea controllerului (de exemplu expresii regulate în ingress-nginx).

ingressClassName leagă Ingress-ul de un controller instalat (ingress-nginx, Traefik, controllerul unui cloud). Fără el, se folosește clasa marcată implicită, iar dacă nu există, Ingress-ul poate fi ignorat, cu 404 de la controller.

Atenție: serviciul api primește calea întreagă, /api/produse. Dacă aplicația așteaptă /produse, ai nevoie de rescriere (adnotarea nginx.ingress.kubernetes.io/rewrite-target cu grupuri de captură) sau, mai curat, configurezi aplicația cu prefixul /api.

Ce urmărește intervievatorul: Se verifică scrierea corectă a unei reguli reale și cunoașterea capcanelor. Mulți candidați uită de rescrierea căii.

Eroarea, în practică:Ingress: 503 Service Temporarily UnavailableIngress: 404 Not Found

45 Mid

Cum activezi HTTPS pe un Ingress și cum automatizezi certificatele?

Răspuns scurt: Pui certificatul și cheia într-un Secret de tip kubernetes.io/tls și îl referi în spec.tls al Ingress-ului, cu hosturile acoperite. Pentru reînnoire automată folosești cert-manager, care obține certificate de la Let's Encrypt (sau altă autoritate) și actualizează Secret-ul.

Varianta manuală:

BASH
kubectl create secret tls magazin-tls --cert=magazin.crt --key=magazin.key -n magazin
YAML
spec:
  ingressClassName: nginx
  tls:
  - hosts: [magazin.ro, www.magazin.ro]
    secretName: magazin-tls
  rules:
  - host: magazin.ro
    http: ...

Controllerul termină TLS și trimite cereri HTTP către poduri. ingress-nginx redirecționează implicit HTTP la HTTPS (308) când Ingress-ul are TLS. Secret-ul trebuie să fie în același namespace cu Ingress-ul.

Cu cert-manager, definești o dată un ClusterIssuer (de exemplu ACME Let's Encrypt cu validare HTTP-01 sau DNS-01) și adaugi o adnotare:

YAML
metadata:
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod

cert-manager creează un obiect Certificate, rezolvă provocarea ACME, scrie Secret-ul și îl reînnoiește înainte de expirare (certificatele Let's Encrypt au în prezent 90 de zile). DNS-01 e necesar pentru certificate wildcard.

De verificat la depanare: kubectl describe certificate, evenimentele challenge-urilor și dacă hostul din tls.hosts coincide cu cel din reguli. Pentru TLS până la pod (end-to-end), configurezi și backend-ul să folosească HTTPS.

Ce urmărește intervievatorul: Intervievatorul verifică experiența cu un aspect obligatoriu în producție. Răspunsul bun pomenește reînnoirea automată.

46 Mid

Un ClusterIP nu răspunde la ping, dar curl spre el funcționează. De ce? Cum funcționează de fapt un ClusterIP?

Răspuns scurt: ClusterIP e o adresă virtuală pe care n-o deține niciun proces. kube-proxy scrie pe fiecare nod reguli (iptables, IPVS, nftables) care rescriu pachetele TCP/UDP spre portul serviciului către un pod. ICMP nu are port, deci ping-ul nu primește răspuns.

Când creezi un serviciu, API server-ul îi alocă un IP din intervalul de servicii (de exemplu 10.96.0.0/12). kube-proxy, pe fiecare nod, urmărește serviciile și EndpointSlices și scrie reguli de tip DNAT:

-A KUBE-SERVICES -d 10.96.118.62/32 -p tcp --dport 80 -j KUBE-SVC-XYZ
-A KUBE-SVC-XYZ -m statistic --mode random --probability 0.5 -j KUBE-SEP-A
-A KUBE-SEP-A -p tcp -j DNAT --to-destination 10.244.1.7:8080

Un pachet care pleacă din pod spre 10.96.118.62:80 e rescris chiar pe nodul sursă către IP-ul unui pod ales aleatoriu. Consecințe:

  • ping spre ClusterIP nu merge, pentru că regulile se potrivesc doar pe protocol și port;
  • distribuția se face pe conexiune, nu pe cerere: o conexiune HTTP/2 sau gRPC persistentă rămâne la același pod;
  • dacă un pod moare, conexiunile lui se rup, iar cele noi merg la podurile rămase după actualizarea regulilor.

Modul IPVS folosește tabele hash și scalează mai bine cu mii de servicii; nftables e modul nou (stabil din 1.33). Cilium poate înlocui complet kube-proxy cu eBPF. Pentru depanare, testezi cu curl sau nc -z, nu cu ping.

Ce urmărește intervievatorul: Se verifică înțelegerea reală a rețelei Kubernetes. Mulți candidați cred că există un proces proxy care ascultă pe ClusterIP.

47 Mid

Scrie un NetworkPolicy care permite accesul la podurile db doar de la podurile api, pe portul 5432. Ce greșeală apare des cu egress-ul?

Răspuns scurt: Un NetworkPolicy cu podSelector app=db, policyTypes Ingress și o singură regulă from podSelector app=api pe portul 5432. Greșeala frecventă: o politică default-deny pe egress care uită DNS-ul (portul 53 spre CoreDNS), după care toate aplicațiile par să nu mai găsească niciun serviciu.

YAML
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: {name: db-doar-api, namespace: magazin}
spec:
  podSelector:
    matchLabels: {app: db}
  policyTypes: [Ingress]
  ingress:
  - from:
    - podSelector:
        matchLabels: {app: api}
    ports:
    - protocol: TCP
      port: 5432

Reguli de bază: un pod nu e selectat de nicio politică, deci acceptă tot. Odată selectat pentru Ingress, acceptă doar ce permite vreo politică (regulile se adună, nu există „deny” explicit). podSelector din from se referă la namespace-ul politicii; pentru alt namespace combini namespaceSelector și podSelector în același element al listei (AND), nu în elemente separate (OR).

Pentru egress, o politică default-deny ar fi:

YAML
spec:
  podSelector: {}
  policyTypes: [Egress]
  egress:
  - to:
    - namespaceSelector: {matchLabels: {kubernetes.io/metadata.name: kube-system}}
      podSelector: {matchLabels: {k8s-app: kube-dns}}
    ports: [{protocol: UDP, port: 53}, {protocol: TCP, port: 53}]

Fără regula de DNS, rezolvarea numelor dă timeout. Și nu uita: politicile funcționează doar dacă pluginul CNI le implementează (Calico, Cilium); altfel sunt ignorate.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți scrie o politică corectă și știi capcanele. Confuzia AND/OR la selectori e o greșeală clasică.

Eroarea, în practică:wget: download timed out (NetworkPolicy)

48 Mid

Aplicația din spatele unui serviciu LoadBalancer vede toate cererile venind de la IP-uri ale nodurilor, nu ale clienților. De ce și ce faci?

Răspuns scurt: Cu externalTrafficPolicy: Cluster, nodul face SNAT ca să trimită traficul la poduri de pe alte noduri, deci IP-ul clientului se pierde. Cu Local, traficul merge doar la podurile locale și IP-ul se păstrează, dar distribuția devine mai puțin uniformă.

Drumul implicit: load balancer-ul extern trimite la un nod oarecare, kube-proxy alege un pod, posibil pe alt nod, și rescrie sursa pachetului (SNAT) cu IP-ul nodului, ca răspunsul să se întoarcă pe același drum. Aplicația vede IP-ul nodului.

YAML
spec:
  type: LoadBalancer
  externalTrafficPolicy: Local

Cu Local:

  • nodul trimite traficul doar podurilor locale, fără SNAT, deci IP-ul clientului ajunge la aplicație;
  • nodurile fără poduri ale serviciului pică verificarea de sănătate a load balancer-ului (healthCheckNodePort) și nu mai primesc trafic;
  • dacă podurile sunt distribuite inegal (3 pe un nod, 1 pe altul), încărcarea pe pod devine inegală; se compensează cu topologySpreadConstraints.

Pentru HTTP există și alte variante: controllerul de Ingress adaugă antetul X-Forwarded-For, iar cu un load balancer L4 poți activa PROXY protocol, cu suport configurat și în controller. În aplicație, citești IP-ul din antet doar dacă vine de la un proxy de încredere.

O setare asemănătoare, internalTrafficPolicy: Local, se folosește pentru traficul din cluster, de exemplu către un agent DaemonSet de pe același nod.

Ce urmărește intervievatorul: Se verifică înțelegerea drumului real al pachetelor și a compromisurilor. Puțini candidați știu de verificarea de sănătate per nod.

49 Senior

Care e diferența dintre Ingress și Gateway API? Ai migra o platformă existentă?

Răspuns scurt: Gateway API e succesorul Ingress-ului: separă rolurile (GatewayClass, Gateway, HTTPRoute) și suportă nativ ponderi, potriviri pe antete, gRPC și TCP, fără adnotări specifice. Aș migra treptat, începând cu aplicațiile care au nevoie de aceste funcții.

Ingress are un model simplu: host și cale către serviciu, plus TLS. Tot restul (rescrieri, canary, timeout-uri, limitare de rată) se face prin adnotări specifice controllerului, deci manifestele nu sunt portabile, iar o echipă de aplicație poate schimba setări care ar trebui să fie ale platformei.

Gateway API (v1 GA din 2023 pentru resursele principale) împarte responsabilitățile:

  • GatewayClass: ce implementare (Envoy Gateway, Istio, Cilium, NGINX Gateway Fabric, controllerele cloud);
  • Gateway: punctele de intrare, porturile și certificatele, gestionate de echipa de platformă;
  • HTTPRoute, GRPCRoute, TLSRoute, TCPRoute: regulile echipelor de aplicații, care se atașează la un Gateway permis, eventual din alt namespace.
YAML
kind: HTTPRoute
spec:
  parentRefs: [{name: public, namespace: infra}]
  hostnames: [magazin.ro]
  rules:
  - backendRefs:
    - {name: magazin-v1, port: 80, weight: 90}
    - {name: magazin-v2, port: 80, weight: 10}

Decizia de migrare: Ingress nu dispare (API-ul e stabil), dar dezvoltarea se concentrează pe Gateway API. Pentru o platformă existentă, aș începe cu aplicațiile noi sau cu cele care au nevoie de canary și potriviri pe antete, aș rula ambele modele în paralel și aș testa comportamentul TLS și al timeout-urilor înainte de mutare. Un punct de atenție e diferența de funcții între implementări.

Ce urmărește intervievatorul: Intervievatorul verifică dacă urmărești direcția ecosistemului și judeci migrările pragmatic. Răspunsul slab e „Gateway API e mai nou, deci mai bun”.

50 Senior

Utilizatorii raportează timeout-uri intermitente când serviciul comenzi apelează serviciul stoc. Cum depanezi?

Răspuns scurt: Clarific tiparul (procent, poduri, moment), verific podurile stoc (reporniri, throttling, OOM), endpoint-urile și livrările recente, apoi testez din comenzi DNS-ul și fiecare pod. Cauze tipice: un pod nesănătos în endpoint-uri, DNS lent, limită de CPU, timeout-uri prea mici.

Un răspuns structurat:

  • Clarific simptomul: de când, ce procent, toate podurile comenzi sau doar unele, corelat cu ore de vârf sau cu livrări. Metricile de latență pe pod (Prometheus, tracing) arată adesea că un singur pod țintă e problema.
  • Starea serviciului țintă:
BASH
kubectl get pods -l app=stoc -o wide
kubectl top pods -l app=stoc
kubectl get endpointslices -l kubernetes.io/service-name=stoc
kubectl rollout history deploy/stoc

Caut reporniri, poduri aproape de limita de memorie, CPU throttling (în metrici, container_cpu_cfs_throttled_periods_total), poduri Ready care de fapt nu răspund (readiness prea permisiv).

  • Test din client: kubectl exec în podul comenzi, apeluri repetate spre serviciu și direct spre fiecare IP de pod. Dacă un singur pod e lent, îl izolez și citesc jurnalul.
  • DNS: timeout-uri de câteva secunde exact pot fi întârzieri DNS (CoreDNS supraîncărcat, ndots:5). Verific metricile CoreDNS.
  • Rețea: NetworkPolicy noi, probleme ale unui nod (comparând podurile după nod).

Remedierea depinde de cauză, iar pe termen lung adaug readiness corect, timeout-uri și reîncercări cu backoff în client, alertă pe latență pe pod și documentez incidentul. Comunicarea cu echipa: actualizări scurte, ce am exclus și ce urmează.

Ce urmărește intervievatorul: Intervievatorul evaluează metoda, nu răspunsul unic. Un candidat bun elimină ipoteze pe rând și nu repornește totul la întâmplare.

ConfigMap și Secret

51 Junior

În ce moduri poate primi un container valorile dintr-un ConfigMap și cum se comportă fiecare când ConfigMap-ul se schimbă?

Răspuns scurt: Prin env cu valueFrom (o cheie), prin envFrom (toate cheile) sau ca fișiere într-un volum. Variabilele de mediu se citesc doar la pornirea containerului, deci cer repornire; fișierele montate se actualizează singure după un timp, cu excepția montărilor cu subPath.

Cele trei variante:

YAML
containers:
- name: api
  env:
  - name: ORAS
    valueFrom:
      configMapKeyRef: {name: setari, key: ORAS}
  envFrom:
  - configMapRef: {name: setari}
    prefix: APP_
  volumeMounts:
  - {name: config, mountPath: /etc/api}
volumes:
- name: config
  configMap: {name: api-config}
  • env + valueFrom: o cheie anume, sub numele de variabilă ales. Eroare la pornire dacă cheia lipsește (optional: true o face opțională).
  • envFrom: toate cheile devin variabile (cu prefix opțional). Cheile care nu sunt nume valide de variabile, de exemplu cu - sau ., sunt sărite.
  • volum: fiecare cheie devine un fișier. Potrivit pentru fișiere de configurare întregi (nginx.conf, application.yaml).

La actualizare: variabilele de mediu fac parte din procesul pornit, deci aplicația vede valorile noi doar după recrearea podului (kubectl rollout restart). Fișierele din volum sunt actualizate de kubelet, de obicei în mai puțin de un minut (prin înlocuirea atomică a unui link simbolic), dar aplicația trebuie să le recitească (inotify, reîncărcare periodică sau semnal).

Alegerea practică: variabile pentru valori simple, citite o dată; fișiere pentru configurări mari sau pentru aplicații care știu să se reîncarce.

Ce urmărește intervievatorul: Se verifică dacă știi consecințele fiecărei metode. Greșeala tipică este să aștepți ca aplicația să vadă singură variabilele noi.

Eroarea, în practică:Database is uninitialized, password not specifiedconfigmap not found (CreateContainerConfigError)

52 Junior

Care e diferența dintre --from-literal, --from-file și --from-env-file la kubectl create configmap?

Răspuns scurt: --from-literal=CHEIE=valoare adaugă o cheie direct din comandă. --from-file face din fiecare fișier o cheie, cu numele fișierului și conținutul lui ca valoare. --from-env-file citește un fișier .env și face câte o cheie din fiecare linie CHEIE=valoare.

Exemplu cu fișierul app.env:

ORAS=Iasi
PROGRAM=9-18
BASH
kubectl create configmap a --from-literal=ORAS=Iasi --from-literal=PROGRAM=9-18
kubectl create configmap b --from-file=app.env
kubectl create configmap c --from-env-file=app.env
kubectl create configmap d --from-file=setari=app.env
kubectl create configmap e --from-file=config/

Rezultate:

  • a și c au cheile ORAS și PROGRAM, potrivite pentru envFrom;
  • b are o singură cheie, app.env, cu tot textul fișierului; montată ca volum, devine fișierul /cale/app.env;
  • d alege explicit numele cheii (setari);
  • e face câte o cheie pentru fiecare fișier din folder.

Greșeala clasică: --from-file=app.env urmat de envFrom, iar aplicația nu găsește variabilele, pentru că există doar cheia app.env, care nu e nici măcar un nume valid de variabilă.

Pentru a ține ConfigMap-urile în git, generezi manifestul cu --dry-run=client -o yaml > setari.yaml. Același tipar actualizează un ConfigMap existent: kubectl create configmap ... --dry-run=client -o yaml | kubectl apply -f -, pentru că create singur dă AlreadyExists.

Ce urmărește intervievatorul: Intervievatorul verifică experiența practică cu ConfigMap-urile. Confuzia dintre from-file și from-env-file e foarte frecventă.

Eroarea, în practică:couldn't find key in ConfigMapconfigmaps "setari" already exists

53 Junior

Ce tipuri de Secret cunoști și cum folosești un Secret ca să descarci imagini dintr-un registry privat?

Răspuns scurt: Cele mai folosite sunt Opaque (valori arbitrare), kubernetes.io/tls (tls.crt și tls.key), kubernetes.io/dockerconfigjson (credențiale de registry) și tokenurile de ServiceAccount. Pentru registry creezi un Secret docker-registry și îl referi în imagePullSecrets din pod sau din ServiceAccount.

Tipul unui Secret validează cheile obligatorii și le spune altor componente cum să-l folosească:

  • Opaque: implicit, pentru parole, chei API, șiruri de conexiune (kubectl create secret generic).
  • kubernetes.io/tls: folosit de Ingress și cert-manager (kubectl create secret tls).
  • kubernetes.io/dockerconfigjson: autentificare la registry.
  • kubernetes.io/basic-auth, kubernetes.io/ssh-auth: convenții pentru alte credențiale.

Pentru registry privat:

BASH
kubectl create secret docker-registry regcred \
  --docker-server=registry.academia.ro \
  --docker-username=ci-bot --docker-password="$TOKEN" -n magazin
YAML
spec:
  imagePullSecrets:
  - name: regcred
  containers:
  - name: api
    image: registry.academia.ro/magazin/api:1.4.2

Ca să nu-l repeți în fiecare pod, îl adaugi la ServiceAccount: kubectl patch serviceaccount default -p '{"imagePullSecrets":[{"name":"regcred"}]}' -n magazin; podurile noi îl primesc automat.

De reținut: Secret-ul trebuie să fie în namespace-ul podului. Dacă lipsește sau credențialele sunt greșite, podul ajunge în ImagePullBackOff cu pull access denied sau 401 Unauthorized. În cloud, nodurile pot avea acces la registry-ul furnizorului prin identitatea mașinii (ECR, Artifact Registry, ACR), fără Secret.

Ce urmărește intervievatorul: Se verifică o situație des întâlnită în proiecte reale. Greșeala tipică este Secret-ul creat în alt namespace.

Eroarea, în practică:pull access denied, repository does not existfailed to fetch anonymous token: 401 Unauthorized

54 Junior

Ai schimbat o valoare într-un ConfigMap folosit prin envFrom, dar aplicația o vede tot pe cea veche. De ce și cum automatizezi actualizarea?

Răspuns scurt: Variabilele de mediu se fixează la crearea containerului. Trebuie recreate podurile: kubectl rollout restart, sau automat, printr-o adnotare cu hash-ul configurației în șablonul podului (tiparul Helm checksum/config) ori prin ConfigMap-uri cu nume versionate generate de Kustomize.

ConfigMap-ul s-a actualizat în API, dar procesul din container a primit variabilele la pornire. Nimic nu repornește podurile automat, pentru că șablonul Deploymentului nu s-a schimbat.

Variante:

  • Manual: kubectl rollout restart deployment/api. Adaugă în șablon adnotarea kubectl.kubernetes.io/restartedAt, care declanșează un rolling update.
  • Hash în șablon (Helm):
YAML
spec:
  template:
    metadata:
      annotations:
        checksum/config: {{ include (print $.Template.BasePath "/configmap.yaml") . | sha256sum }}

Când conținutul ConfigMap-ului se schimbă, hash-ul se schimbă, șablonul diferă, iar helm upgrade face rolling update.

  • Nume versionate (Kustomize): configMapGenerator creează setari-7g8h9k cu un sufix din hash și actualizează referințele. Avantaj: rollback-ul Deploymentului revine și la configurația veche, care încă există.
  • Controllere externe precum Reloader, care urmăresc ConfigMap-urile și repornesc Deploymenturile adnotate.

Alternativ, aplicația poate citi configurația din fișiere montate și se poate reîncărca singură, fără repornire. Indiferent de metodă, schimbarea configurației ar trebui să treacă prin același proces de livrare ca și codul.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi legătura dintre configurație și ciclul de viață al podurilor. Mulți candidați nu știu de tiparul checksum.

55 Junior

Ai montat un singur fișier dintr-un ConfigMap cu subPath. După actualizarea ConfigMap-ului, fișierul din pod a rămas vechi. De ce?

Răspuns scurt: Montările cu subPath sunt legături fixe către fișierul existent la pornirea containerului; kubelet-ul actualizează volumul prin înlocuirea unui link simbolic, iar subPath nu vede schimbarea. Soluții: montezi tot ConfigMap-ul într-un folder separat, folosești items pentru a alege fișierul, sau repornești podul.

subPath e folosit când vrei să pui un singur fișier într-un folder care are deja alte fișiere, fără să-l acoperi:

YAML
volumeMounts:
- name: config
  mountPath: /etc/nginx/conf.d/default.conf
  subPath: default.conf

Fără subPath, montarea pe /etc/nginx/conf.d ar ascunde toate fișierele existente din acel folder al imaginii.

Mecanismul de actualizare: kubelet-ul scrie conținutul nou într-un folder cu marcaj de timp, apoi schimbă atomic link-ul ..data. Montarea completă urmează link-ul și vede fișierele noi. O montare subPath e legată de fișierul concret de la pornire, deci rămâne cu versiunea veche până la recrearea containerului. Același comportament îl au Secret-urile și volumele proiectate montate cu subPath.

Variante:

  • montezi ConfigMap-ul într-un folder propriu (/etc/api/config) și configurezi aplicația să citească de acolo;
  • cu items, alegi ce chei devin fișiere și sub ce nume, tot fără subPath;
  • dacă subPath e inevitabil, asociezi schimbarea configurației cu un rollout (hash în adnotare).

O altă capcană: aplicațiile care urmăresc fișierul cu inotify pe calea directă pot rata înlocuirea link-ului; e mai sigur să urmărească folderul.

Ce urmărește intervievatorul: Se verifică o capcană reală, întâlnită des în producție. Răspunsul bun explică mecanismul cu link simbolic.

Eroarea, în practică:Cannot find module './config.json'

56 Mid

Ce aduce un ConfigMap sau Secret marcat immutable: true și cum lucrezi cu el?

Răspuns scurt: Conținutul nu mai poate fi modificat, iar kubelet-ul nu-l mai urmărește pentru schimbări, ceea ce reduce încărcarea API server-ului în clustere mari și previne schimbările accidentale. Pentru o configurație nouă creezi un obiect nou, cu nume versionat, și actualizezi referința din Deployment.

YAML
apiVersion: v1
kind: ConfigMap
metadata: {name: setari-v3}
immutable: true
data:
  TEMA: inchis

După creare, orice modificare a data dă field is immutable when immutable is set, iar câmpul immutable nu mai poate fi scos. Singura operație permisă e ștergerea.

Avantaje:

  • siguranță: o editare greșită nu poate ajunge instantaneu în toate podurile; schimbarea trece printr-un rollout, cu readiness, și poate fi anulată cu rollout undo, pentru că versiunea veche încă există;
  • performanță: kubelet-ul nu mai deschide un watch pentru fiecare ConfigMap montat; în clustere cu zeci de mii de poduri diferența contează pentru API server.

Fluxul de lucru: setari-v3 nou, schimbi configMapRef.name în Deployment, aplici, urmărești rollout-ul, apoi ștergi versiunile care nu mai sunt referite. Kustomize (configMapGenerator cu immutable: true) și Helm (nume cu hash) pot automatiza denumirea.

Dezavantaj: se adună obiecte vechi, deci ai nevoie de curățenie (manuală sau prin unealta de livrare, de exemplu prune în Argo CD).

Ce urmărește intervievatorul: Intervievatorul verifică practicile de configurare sigură. Puțini candidați știu de beneficiul de performanță.

Eroarea, în practică:field is immutable when `immutable` is set

57 Mid

Echipa vrea toate manifestele în git, inclusiv Secret-urile. Ce variante ai, ca parolele să nu ajungă în clar în repository?

Răspuns scurt: Sealed Secrets (Secret criptat cu cheia publică a unui controller din cluster), SOPS cu age sau KMS (fișiere criptate, decriptate la livrare) ori External Secrets Operator, unde git conține doar referința, iar valoarea vine din Vault sau din managerul de secrete al cloud-ului.

Un Secret Kubernetes e doar codat base64, deci un manifest cu data: în git e practic parola în clar, accesibilă oricui are acces la repository și la istoric.

  • Sealed Secrets: kubeseal criptează Secret-ul cu cheia publică a controllerului; în git stă un SealedSecret, pe care doar controllerul din cluster îl poate decripta. Simplu, dar legat de cheia clusterului (backup-ul cheii e obligatoriu).
  • SOPS (cu age, PGP sau KMS din cloud): criptează valorile din YAML, lăsând cheile vizibile, deci diff-urile rămân lizibile. Argo CD și Flux îl pot decripta la livrare.
  • External Secrets Operator: în git pui un ExternalSecret care spune „ia cheia prod/db/password din Vault”, iar operatorul creează și actualizează Secret-ul. Sursa adevărului e managerul de secrete, cu audit și rotație.
  • Secrets Store CSI Driver: montează secretele direct din manager ca fișiere, opțional și ca Secret Kubernetes.

Criterii de alegere: dacă organizația are deja Vault sau un manager cloud, External Secrets e de obicei cea mai bună alegere; pentru echipe mici, Sealed Secrets sau SOPS. Oricum ar fi, adaugi un scanner de secrete (gitleaks) în pipeline, iar o parolă ajunsă din greșeală în git se consideră compromisă și se rotește, nu doar se șterge din istoric.

Ce urmărește intervievatorul: Se verifică maturitatea în gestionarea secretelor. Greșeala gravă este să consideri base64 o protecție.

Eroarea, în practică:Secret: illegal base64 data at input byte

58 Mid

Cum gestionezi configurații diferite pentru dev, staging și producție fără să copiezi manifestele de trei ori?

Răspuns scurt: Ții o bază comună și diferențele per mediu: cu Kustomize (base plus overlays cu patch-uri, imagini și ConfigMap-uri generate) sau cu Helm (un chart și câte un fișier de valori pe mediu). Secretele vin separat, iar promovarea între medii schimbă de obicei doar tagul imaginii.

Cu Kustomize (integrat în kubectl apply -k):

k8s/
  base/        deployment.yaml service.yaml kustomization.yaml
  overlays/
    dev/       kustomization.yaml
    prod/      kustomization.yaml replici.yaml
YAML
# overlays/prod/kustomization.yaml
resources: [../../base]
namespace: magazin-prod
images:
- {name: academia/magazin, newTag: "1.4.2"}
patches:
- path: replici.yaml
configMapGenerator:
- name: setari
  literals: [NIVEL_LOG=warn]

Cu Helm: un chart cu șabloane și values.yaml cu valori implicite, plus values-dev.yaml și values-prod.yaml cu diferențele (replici, resurse, host-ul Ingress-ului): helm upgrade --install magazin ./chart -f values-prod.yaml.

Principii care contează mai mult decât unealta:

  • diferențele dintre medii sunt mici și vizibile, ușor de revizuit într-un pull request;
  • aceeași imagine (același digest) trece prin toate mediile, doar configurația diferă;
  • secretele nu stau în aceste fișiere în clar;
  • producția e livrată din git prin pipeline sau GitOps, nu cu comenzi manuale.

Kustomize e mai simplu pentru aplicațiile proprii, Helm e mai bun pentru distribuirea și parametrizarea pachetelor.

Ce urmărește intervievatorul: Intervievatorul verifică organizarea unui proiect real. Răspunsul slab descrie trei copii ale acelorași fișiere.

59 Senior

Cine poate, de fapt, citi Secret-urile dintr-un cluster și cum le protejezi mai bine?

Răspuns scurt: Oricine are get, list sau watch pe secrets, dar și oricine poate crea poduri în namespace, administratorii nodurilor și cine ajunge la etcd sau la backup-uri. Protecția: RBAC strict, criptare în etcd cu KMS, audit și manageri externi de secrete.

Căi de acces de care se uită des:

  • RBAC direct: get secrets. Atenție: list și watch întorc și valorile, nu doar numele.
  • Crearea de poduri: cine poate crea un pod (sau un Deployment, un Job) într-un namespace poate monta orice Secret din namespace și să-l afișeze. Practic, create pods echivalează cu citirea secretelor.
  • ServiceAccount-uri: un pod care rulează cu un ServiceAccount puternic moștenește drepturile lui.
  • Nodul: kubelet-ul are secretele podurilor de pe nod, iar cine are root pe nod le poate citi.
  • etcd și backup-urile: implicit, Secret-urile sunt stocate necriptate în etcd (doar base64).

Măsuri:

  • criptare în repaus cu EncryptionConfiguration, ideal cu un furnizor KMS (cheia stă în afara clusterului); în clusterele gestionate se activează din setările furnizorului;
  • RBAC minim, fără drepturi pe secrets pentru oameni în producție, și separarea namespace-urilor sensibile;
  • automountServiceAccountToken: false unde nu e nevoie de API;
  • audit log pe accesul la secrets;
  • secrete cu viață scurtă și rotație, de preferat din Vault sau din managerul cloud.

Un model de amenințare clar ajută la interviu: împotriva cui protejezi (dezvoltator curios, atacator într-un pod, furt de backup) și ce măsură acoperă fiecare caz.

Ce urmărește intervievatorul: Se verifică gândirea de securitate la nivel de sistem. Aproape toți candidații uită că dreptul de a crea poduri permite citirea secretelor.

Eroarea, în practică:couldn't find key in Secret

Resurse, probe și programare

Exersează capitolul cu exerciții reale: Curs Kubernetes online →
60 Junior

Ce sunt clasele QoS (Guaranteed, Burstable, BestEffort) și cum le obții?

Răspuns scurt: Clasa e calculată din requests și limits: Guaranteed când fiecare container are requests egale cu limits pentru CPU și memorie, BestEffort când nu are niciun container requests sau limits, iar Burstable în rest. Ea decide ordinea evacuării când nodul rămâne fără memorie.

Kubernetes nu-ți cere să alegi clasa: o deduce și o scrie în status.qosClass.

YAML
# Guaranteed
resources:
  requests: {cpu: 500m, memory: 512Mi}
  limits:   {cpu: 500m, memory: 512Mi}
# Burstable
resources:
  requests: {cpu: 100m, memory: 256Mi}
  limits:   {memory: 512Mi}
# BestEffort: fără resources deloc
BASH
kubectl get pod db -o jsonpath='{.status.qosClass}'

Ce influențează clasa:

  • evacuarea la presiune de memorie pe nod: kubelet-ul alege întâi podurile BestEffort și Burstable care depășesc requests, iar Guaranteed rămân ultimele;
  • scorul OOM al proceselor: kernelul omoară mai întâi procesele din poduri BestEffort.

Când alegi Guaranteed: baze de date, servicii critice sensibile la latență, mai ales cu politica static a CPU manager-ului, care poate da nuclee dedicate podurilor Guaranteed cu CPU întreg. Prețul: nu poți folosi capacitatea liberă a nodului peste limită.

Burstable e varianta obișnuită pentru aplicații web. BestEffort se potrivește doar pentru sarcini care pot fi oprite oricând, iar în multe clustere e interzis prin LimitRange sau politici.

Ce urmărește intervievatorul: Intervievatorul verifică legătura dintre resurse și stabilitate. Greșeala tipică este să crezi că clasa se setează explicit.

Eroarea, în practică:requests must be less than or equal to limit

61 Junior

Ce se întâmplă dacă nu setezi deloc requests pentru containerele aplicației?

Răspuns scurt: Scheduler-ul crede că podul nu cere nimic și îl pune pe noduri deja încărcate, podul devine BestEffort (primul evacuat), HPA-ul pe CPU nu poate calcula procentul, iar o cotă pe requests refuză podul. Un LimitRange poate da valori implicite.

requests sunt rezervarea pe care se bazează programarea, nu un consum măsurat. Fără ele:

  • programare oarbă: scheduler-ul vede requests 0 și poate pune zeci de poduri pe același nod. Când toate încep să consume, nodul ajunge la presiune de memorie sau CPU, iar aplicațiile încetinesc sau sunt evacuate;
  • QoS BestEffort: la presiune de memorie, podurile tale sunt primele oprite;
  • HPA: o țintă de tip averageUtilization: 70 pentru CPU arată <unknown>, pentru că procentul se calculează față de requests;
  • cote: un ResourceQuota pe requests.cpu refuză podurile fără requests (failed quota: must specify requests.cpu), iar la un Deployment eroarea apare doar în evenimentele ReplicaSet-ului;
  • cluster autoscaler: decide să adauge noduri pe baza requests ale podurilor Pending, deci fără requests nu adaugă capacitate la timp.

Cum alegi valorile: pornești de la consumul măsurat în condiții normale (kubectl top pods, Prometheus, recomandările VPA în mod Off), pui requests aproape de consumul tipic și o limită de memorie cu rezervă. Verifici periodic, pentru că supradimensionarea irosește bani, iar subdimensionarea aduce instabilitate.

Ce urmărește intervievatorul: Se verifică înțelegerea efectelor în lanț ale unei setări aparent opționale. Mulți candidați cunosc doar efectul asupra programării.

Eroarea, în practică:0/3 nodes are available: Insufficient cpu

62 Junior

Ce înseamnă cpu: 250m, memory: 512Mi și memory: 512M? Ce greșeală se face des cu memory: 1g?

Răspuns scurt: 250m înseamnă un sfert de nucleu. 512Mi înseamnă 512 × 1024 × 1024 bytes, iar 512M înseamnă 512 × 1000 × 1000 bytes. 1g nu e valid, pentru că sufixele sunt sensibile la majuscule, iar 512m la memorie ar însemna 0,512 bytes.

Pentru CPU, unitatea e nucleul: 1 sau 1000m înseamnă un nucleu (sau un vCPU), 0.5 e la fel cu 500m. Precizia minimă e 1m. CPU se împarte pe timp: un container cu limită 250m poate folosi 25 ms de CPU la fiecare 100 ms.

Pentru memorie, cantitatea e în bytes, cu sufixe:

  • binare: Ki, Mi, Gi, Ti (puteri ale lui 1024);
  • zecimale: k, M, G, T (puteri ale lui 1000).

1Gi = 1.073.741.824 bytes, iar 1G = 1.000.000.000 bytes. Pentru limite de memorie se folosesc aproape mereu unitățile binare, pentru că așa raportează și uneltele (kubectl top, cgroups).

Greșeli frecvente:

  • memory: 1g sau 1gb dă quantities must match the regular expression;
  • memory: 512m e acceptat, dar înseamnă 0,512 bytes (m e mili), deci podul nu pornește sau e omorât imediat;
  • cpu: 2 față de cpu: "2" sunt echivalente, dar cpu: 0,5 cu virgulă e invalid.

Verifici ce a înțeles serverul cu kubectl get pod api -o jsonpath='{.spec.containers[0].resources}'.

Ce urmărește intervievatorul: Intervievatorul verifică atenția la unități, sursă de incidente reale. Capcana cu m mic la memorie îi prinde pe mulți.

Eroarea, în practică:must be a valid quantity

63 Junior

Cum îți asiguri că podurile unei aplicații ajung doar pe nodurile cu GPU și că alte aplicații nu ocupă acele noduri?

Răspuns scurt: Pui un taint pe nodurile cu GPU (de exemplu gpu=true:NoSchedule), ca podurile fără toleration să nu ajungă acolo, iar podurile aplicației primesc toleration-ul plus un nodeSelector sau o nodeAffinity pe o etichetă a nodurilor. Taint-ul respinge, afinitatea atrage: ai nevoie de ambele.

Două mecanisme cu roluri diferite:

  • Taints și tolerations: taint-ul de pe nod respinge podurile care nu-l tolerează. Toleration-ul permite podului să ajungă pe nod, dar nu-l obligă.
  • nodeSelector și nodeAffinity: podul cere noduri cu anumite etichete. Nu împiedică alte poduri să ajungă acolo.
BASH
kubectl taint nodes gpu-1 gpu=true:NoSchedule
kubectl label nodes gpu-1 accelerator=nvidia
YAML
spec:
  tolerations:
  - {key: gpu, operator: Equal, value: "true", effect: NoSchedule}
  nodeSelector:
    accelerator: nvidia
  containers:
  - name: antrenare
    resources:
      limits: {nvidia.com/gpu: 1}

Efectele unui taint: NoSchedule (podurile noi nu sunt programate), PreferNoSchedule (evitate dacă se poate) și NoExecute (sunt evacuate și podurile care rulează deja, util la mentenanță; Kubernetes îl folosește pentru nodurile not-ready).

nodeAffinity oferă mai mult decât nodeSelector: operatori (In, NotIn, Exists, Gt) și reguli preferate, cu ponderi, în plus față de cele obligatorii. Nodurile control plane au implicit taint-ul node-role.kubernetes.io/control-plane:NoSchedule, de aceea aplicațiile nu ajung acolo.

Ce urmărește intervievatorul: Se verifică dacă știi că taint-ul și afinitatea rezolvă probleme diferite. Greșeala tipică este să folosești doar una dintre ele.

Eroarea, în practică:untolerated taint control-planenode(s) had untolerated taint {dedicat: gpu}

64 Junior

Care e diferența dintre LimitRange și ResourceQuota?

Răspuns scurt: LimitRange se aplică fiecărui container sau pod în parte: valori implicite pentru requests și limits, minime și maxime. ResourceQuota limitează totalul unui namespace: suma requests și limits, numărul de poduri, servicii, PVC-uri și altele.

Ambele sunt verificate de admission controllere la crearea obiectelor, nu pentru podurile existente.

LimitRange (per container):

YAML
apiVersion: v1
kind: LimitRange
metadata: {name: implicite, namespace: echipa}
spec:
  limits:
  - type: Container
    defaultRequest: {cpu: 100m, memory: 128Mi}
    default: {memory: 256Mi}
    max: {memory: 1Gi}

Containerele fără resurse primesc valorile implicite; cele care cer peste 1Gi sunt refuzate (maximum memory usage per Container is 1Gi).

ResourceQuota (pe namespace):

YAML
apiVersion: v1
kind: ResourceQuota
metadata: {name: cota, namespace: echipa}
spec:
  hard:
    requests.cpu: "4"
    requests.memory: 8Gi
    limits.memory: 16Gi
    pods: "30"
    persistentvolumeclaims: "10"

Podul care ar depăși totalul e refuzat cu exceeded quota, iar kubectl describe quota arată Used și Hard.

Le folosești împreună: cota protejează clusterul de o echipă care consumă prea mult, iar LimitRange-ul face ca podurile fără resurse să fie acceptate (o cotă pe requests cere ca fiecare pod să declare requests). La un Deployment, refuzurile apar în evenimentele ReplicaSet-ului, deci o echipă poate vedea 0/3 fără să înțeleagă de ce.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi instrumentele pentru clustere folosite de mai multe echipe. Confuzia dintre cele două e frecventă.

Eroarea, în practică:failed quota: must specify requests.cpumaximum memory usage per Container is 512Mi

65 Mid

De ce o limită de CPU poate crește latența unei aplicații chiar dacă nodul are CPU liber? Ai seta limite de CPU?

Răspuns scurt: Limita de CPU e aplicată prin cotă CFS: dacă containerul își consumă cota într-o perioadă de 100 ms, e oprit până la perioada următoare, chiar cu nuclee libere pe nod. Multe echipe renunță la limitele de CPU pentru serviciile sensibile la latență.

Cu limits.cpu: 500m, kernelul permite containerului 50 ms de CPU la fiecare 100 ms, însumat pe toate firele de execuție. O aplicație cu 8 fire care procesează în paralel o cerere poate consuma cei 50 ms în aproximativ 6 ms, apoi stă blocată restul de 94 ms. Utilizarea medie arată mică, dar latența p99 crește mult.

Semnele: metrica container_cpu_cfs_throttled_periods_total crește, latența are vârfuri la intervale regulate, iar kubectl top arată consum sub limită.

Compromisul:

  • cu limite: costuri și vecini previzibili, dar throttling și o capacitate liberă nefolosită;
  • fără limite, cu requests corecte: CPU-ul liber al nodului poate fi folosit, iar requests garantează partea fiecăruia la concurență (prin ponderi CFS). Riscul: un pod defect poate consuma mult, dar nu-i poate lua altuia partea garantată.

Recomandarea frecventă: requests pentru CPU peste tot, limite de CPU doar unde e nevoie de izolare strictă sau de facturare, limite de memorie mereu (memoria nu se poate împrumuta și recupera ca CPU-ul). Pentru runtime-uri care își dimensionează firele după CPU (JVM, Go cu GOMAXPROCS), configurezi explicit numărul de fire în acord cu requests.

Ce urmărește intervievatorul: Se verifică experiența cu probleme reale de performanță. Răspunsul matur prezintă compromisul, nu o regulă absolută.

66 Mid

Nodul rămâne fără memorie. Cum decide kubelet-ul ce poduri evacuează și ce înseamnă statusul Evicted?

Răspuns scurt: La presiune de memorie, kubelet-ul evacuează întâi podurile care își depășesc requests, după prioritate și consum, iar Guaranteed rămân ultimele. Podul evacuat rămâne Failed cu motivul Evicted, iar controllerul lui creează altul pe alt nod.

Kubelet-ul are praguri de evacuare (implicit memory.available<100Mi, nodefs.available<10%, imagefs.available<15%). Când un prag e depășit:

  • nodul primește condiția MemoryPressure (sau DiskPressure) și un taint, ca să nu primească poduri noi;
  • kubelet-ul alege podurile de evacuat după: dacă consumul depășește requests, priorityClassName și cât depășesc requests;
  • podurile Guaranteed și cele care stau sub requests sunt evacuate ultimele.

Un pod evacuat nu e șters: rămâne în faza Failed cu reason: Evicted și un mesaj (The node was low on resource: memory). Deploymentul creează imediat un înlocuitor. Podurile evacuate vechi se pot șterge cu kubectl delete pod --field-selector=status.phase=Failed.

Diferența față de OOMKilled: OOMKilled înseamnă că un container și-a depășit propria limită și a fost omorât de kernel, apoi repornit în același pod. Evicted e decizia kubelet-ului pentru a salva nodul. Dacă presiunea crește prea repede, kernelul poate interveni înaintea kubelet-ului (OOM la nivel de nod).

Prevenție: requests realiste (ca scheduler-ul să nu supraîncarce nodul), limite de memorie, PriorityClass pentru serviciile critice și monitorizarea nodurilor.

Ce urmărește intervievatorul: Intervievatorul verifică înțelegerea mecanismelor de protecție ale nodului. Mulți confundă evacuarea cu OOMKilled.

67 Mid

Un HPA are ținta de 60% CPU. 4 poduri cu requests de 200m consumă în medie 180m. Câte replici va cere HPA-ul? Ce oprește oscilațiile?

Răspuns scurt: Utilizarea curentă e 180/200 = 90%. Formula e ceil(4 × 90 / 60) = 6 replici. Oscilațiile sunt reduse de toleranța de 10%, de fereastra de stabilizare la scalarea în jos (implicit 300 de secunde) și de politicile din câmpul behavior.

HPA-ul (autoscaling/v2) calculează la fiecare 15 secunde:

replici_dorite = ceil(replici_curente × valoare_curentă / valoare_țintă)
               = ceil(4 × 90% / 60%) = ceil(6) = 6

Apoi aplică limitele minReplicas și maxReplicas. Detalii:

  • utilizarea e calculată față de requests, de aceea fără requests ținta e <unknown>;
  • podurile care încă pornesc sau nu sunt Ready sunt tratate conservator, ca să nu scaleze după vârful de CPU de la pornire;
  • dacă raportul e în toleranța de 10% (de exemplu 63% față de 60%), nu se schimbă nimic;
  • cu mai multe metrici, se alege numărul cel mai mare de replici.

Comportamentul se reglează cu behavior:

YAML
behavior:
  scaleDown:
    stabilizationWindowSeconds: 300
    policies: [{type: Percent, value: 50, periodSeconds: 60}]
  scaleUp:
    policies: [{type: Pods, value: 4, periodSeconds: 60}]

Scalarea în jos folosește recomandarea cea mai mare din ultimele 5 minute, deci nu scade imediat după un vârf scurt. Pentru încărcări care nu se reflectă în CPU (lungimea unei cozi, cereri pe secundă), folosești metrici custom sau externe, de exemplu prin KEDA.

Ce urmărește intervievatorul: Se verifică dacă știi mecanismul de calcul, nu doar că HPA-ul există. Mulți nu știu că procentul e raportat la requests.

Eroarea, în practică:HPA: missing request for cpu (cpu: <unknown>)

68 Mid

Aplicația Java pornește în 2 minute, iar liveness probe-ul o repornește înainte să fie gata. Cum configurezi corect probe-urile?

Răspuns scurt: Adaugi un startupProbe cu failureThreshold × periodSeconds mai mare decât timpul maxim de pornire; liveness și readiness nu rulează până nu trece. Liveness verifică doar dacă procesul e viu (fără dependențe externe), readiness verifică dacă poate servi trafic.

Fără startup probe, liveness-ul începe după initialDelaySeconds. Dacă pornirea durează uneori mai mult decât ai estimat, kubelet-ul omoară containerul în timpul pornirii și se intră într-un ciclu de reporniri.

YAML
startupProbe:
  httpGet: {path: /health/liveness, port: 8080}
  periodSeconds: 10
  failureThreshold: 18      # până la 180 s pentru pornire
livenessProbe:
  httpGet: {path: /health/liveness, port: 8080}
  periodSeconds: 10
  failureThreshold: 3
readinessProbe:
  httpGet: {path: /health/readiness, port: 8080}
  periodSeconds: 5
  failureThreshold: 2

Cum funcționează: cât timp startup probe-ul nu a reușit, celelalte nu rulează. După primul succes, nu mai rulează, iar liveness-ul preia, cu o toleranță scurtă.

Anti-tipare frecvente:

  • liveness care verifică baza de date: dacă baza de date are o problemă, toate podurile sunt repornite simultan, ceea ce agravează incidentul;
  • același endpoint pentru liveness și readiness, cu verificări grele;
  • timeout-uri prea mici (implicit timeoutSeconds: 1) pentru o aplicație care face pauze de garbage collection;
  • un liveness inutil: dacă procesul iese singur la blocaj, repornirea se face oricum.

Spring Boot Actuator oferă separat /actuator/health/liveness și /readiness, exact pentru acest model.

Ce urmărește intervievatorul: Intervievatorul verifică experiența cu aplicații reale care pornesc greu. Liveness-ul care verifică dependențele e o greșeală foarte frecventă.

Eroarea, în practică:Liveness probe failed: statuscode: 404Liveness probe failed: connection refused

69 Senior

Cum te asiguri că replicile unei aplicații critice nu ajung toate pe același nod sau în aceeași zonă?

Răspuns scurt: Folosești topologySpreadConstraints pe topology.kubernetes.io/zone și kubernetes.io/hostname, cu maxSkew 1, sau podAntiAffinity. Le combini cu un PodDisruptionBudget și cu suficientă capacitate în fiecare zonă, ca răspândirea să nu blocheze programarea.

Implicit, scheduler-ul încearcă să răspândească podurile aceluiași serviciu, dar nu garantează. Pentru garanții:

YAML
spec:
  topologySpreadConstraints:
  - maxSkew: 1
    topologyKey: topology.kubernetes.io/zone
    whenUnsatisfiable: DoNotSchedule
    labelSelector: {matchLabels: {app: plati}}
  - maxSkew: 1
    topologyKey: kubernetes.io/hostname
    whenUnsatisfiable: ScheduleAnyway
    labelSelector: {matchLabels: {app: plati}}

Prima regulă cere ca diferența dintre zone să fie cel mult 1 pod (strict), a doua preferă noduri diferite (flexibil). podAntiAffinity cu requiredDuringScheduling și topologyKey: kubernetes.io/hostname interzice două poduri pe același nod, dar cu 5 replici pe 3 noduri lasă 2 poduri în Pending, deci e mai rigid.

Decizii de echilibru:

  • DoNotSchedule garantează disponibilitatea, dar poate lăsa poduri Pending dacă o zonă e plină;
  • ScheduleAnyway nu blochează, dar acceptă dezechilibre;
  • răspândirea e calculată doar la programare; după căderea unei zone, podurile mutate nu revin automat (descheduler poate ajuta).

Restul tabloului: cel puțin 3 replici pentru 3 zone, PDB cu maxUnavailable: 1, volume în zona corectă (WaitForFirstConsumer) și teste reale, de exemplu golirea unei zone întregi.

Ce urmărește intervievatorul: Se verifică proiectarea pentru disponibilitate. Un candidat senior discută compromisul dintre strict și flexibil.

Volume și stocare persistentă

70 Junior

Care e diferența dintre un volum emptyDir, unul hostPath și un PersistentVolumeClaim?

Răspuns scurt: emptyDir e un folder temporar care trăiește cât podul, bun pentru cache și partajare între containere. hostPath montează un folder al nodului, riscant și legat de nod. Un PVC cere stocare persistentă, care supraviețuiește podului și îl urmează pe alt nod.

  • emptyDir: există cât trăiește podul (supraviețuiește repornirii containerelor, nu ștergerii podului). Util pentru cache, fișiere temporare sau ca loc comun între un init container și aplicație ori între aplicație și un sidecar. Cu medium: Memory e un tmpfs, iar consumul se numără la memoria containerului. Poți limita mărimea cu sizeLimit.
  • hostPath: un folder sau un fișier de pe nod. Datele rămân pe acel nod, deci un pod mutat pe alt nod nu le mai vede. E și un risc de securitate: hostPath: / sau /var/run/containerd/containerd.sock dă practic control asupra nodului. Îl folosesc agenții de sistem (colectoare de loguri, pluginuri CSI), iar politicile Pod Security baseline îl interzic pentru aplicații.
  • PVC: o cerere de stocare („10Gi, ReadWriteOnce, clasa standard”), legată de un PersistentVolume real (disc în cloud, NFS, volum local). Datele rămân după ștergerea podului și sunt atașate nodului pe care rulează podul nou.
YAML
volumes:
- name: cache
  emptyDir: {sizeLimit: 1Gi}
- name: date
  persistentVolumeClaim: {claimName: date-magazin}

Regula: date pe care nu vrei să le pierzi doar pe PVC, și chiar și atunci cu backup.

Ce urmărește intervievatorul: Intervievatorul verifică dacă alegi corect tipul de volum. Greșeala tipică este hostPath folosit ca stocare persistentă pentru aplicații.

Eroarea, în practică:cannot delete Pods with local storage

71 Junior

Explică legătura dintre PersistentVolume, PersistentVolumeClaim și StorageClass. Ce înseamnă provizionare dinamică?

Răspuns scurt: PV-ul e bucata de stocare reală, la nivel de cluster. PVC-ul e cererea unei aplicații, într-un namespace. StorageClass descrie un tip de stocare și provisionerul care îl creează. Provizionarea dinamică înseamnă că, la un PVC nou, provisionerul clasei creează automat un PV potrivit.

Modelul separă cine consumă stocarea de cine o oferă:

  • PersistentVolumeClaim (namespace): „am nevoie de 20Gi, ReadWriteOnce, clasa ssd”. Aplicația îl referă după nume.
  • PersistentVolume (cluster): un disc concret, cu capacitate, mod de acces, reclaimPolicy și detaliile driverului (ID-ul discului EBS, calea NFS).
  • StorageClass (cluster): un „tip” de stocare, cu provisioner (de exemplu ebs.csi.aws.com, rancher.io/local-path), parametri (tip de disc, IOPS), reclaimPolicy, volumeBindingMode și allowVolumeExpansion.
YAML
apiVersion: v1
kind: PersistentVolumeClaim
metadata: {name: date}
spec:
  storageClassName: standard
  accessModes: [ReadWriteOnce]
  resources: {requests: {storage: 10Gi}}

Cu provizionare dinamică, driverul CSI creează discul și PV-ul când e nevoie, iar PVC-ul devine Bound. Fără ea (provizionare statică), un administrator creează PV-uri dinainte, iar PVC-urile se leagă de un PV compatibil (capacitate cel puțin egală, același mod de acces și clasă).

Dacă storageClassName lipsește, se folosește clasa marcată implicită. storageClassName: "" înseamnă explicit „fără clasă”, deci doar PV-uri statice. kubectl get pv,pvc și kubectl describe pvc arată legătura și evenimentele de provizionare.

Ce urmărește intervievatorul: Se verifică modelul de stocare de bază. Mulți candidați confundă PV cu PVC.

Eroarea, în practică:pod has unbound immediate PersistentVolumeClaimsProvisioningFailed: storageclass not found

72 Junior

Ce înseamnă modurile de acces ReadWriteOnce, ReadOnlyMany, ReadWriteMany și ReadWriteOncePod?

Răspuns scurt: RWO: scriere de pe un singur nod (podurile de pe el pot folosi volumul). ROX: citire de pe mai multe noduri. RWX: scriere de pe mai multe noduri, cu stocare de tip fișier (NFS, EFS). RWOP: un singur pod din tot clusterul.

Modul de acces descrie ce suportă stocarea, nu doar ce îți dorești:

  • ReadWriteOnce (RWO): discurile bloc (EBS, Persistent Disk, Azure Disk, local-path) se atașează unui singur nod. Atenție, „once” înseamnă un nod, nu un pod.
  • ReadOnlyMany (ROX): date citite de multe poduri, de exemplu un set de modele sau resurse statice.
  • ReadWriteMany (RWX): sisteme de fișiere în rețea (NFS, CephFS, Amazon EFS, Azure Files). Necesar când mai multe replici pe noduri diferite scriu în același folder.
  • ReadWriteOncePod (RWOP): stabil din Kubernetes 1.29, doar cu drivere CSI. Garantează un singur pod, util pentru aplicații care nu suportă doi scriitori.

Ce se întâmplă când alegi greșit: un PVC RWX pe o clasă care nu îl suportă rămâne Pending (ProvisioningFailed); un Deployment cu 3 replici și un PVC RWO pornește doar podurile de pe nodul care are discul, iar celelalte rămân în ContainerCreating cu Multi-Attach error.

Întrebarea de design: chiar ai nevoie de RWX? Pentru fișiere încărcate de utilizatori, un object storage (S3, MinIO) e de obicei mai scalabil și mai ieftin decât un volum partajat. Modul de acces e imutabil pe un PVC existent.

Ce urmărește intervievatorul: Intervievatorul verifică o confuzie frecventă. Greșeala tipică este să crezi că RWO înseamnă un singur pod.

Eroarea, în practică:Only support ReadWriteOnce access mode

73 Junior

Ce face persistentVolumeReclaimPolicy și ce se întâmplă cu datele când ștergi un PVC?

Răspuns scurt: reclaimPolicy decide soarta PV-ului după ștergerea PVC-ului: Delete șterge și volumul, cu datele; Retain păstrează volumul cu statusul Released, pentru recuperare manuală. Clasele dinamice au de obicei Delete, deci ștergerea unui PVC șterge datele.

Ciclul unui PV legat: Bound cât timp există PVC-ul. După ștergerea PVC-ului:

  • Delete: driverul șterge discul real și obiectul PV. E valoarea implicită pentru clasele dinamice, deci un kubectl delete pvc sau un helm uninstall care șterge PVC-urile poate distruge date de producție.
  • Retain: PV-ul trece în Released și păstrează datele, dar nu poate fi legat automat de un PVC nou, pentru că are încă referința la vechiul PVC (claimRef). Recuperarea e manuală: fie ștergi claimRef, ca PV-ul să devină Available, fie creezi un PV nou care indică același disc.
BASH
kubectl patch pv pvc-1e5f... -p '{"spec":{"persistentVolumeReclaimPolicy":"Retain"}}'

Politica se poate schimba pe un PV existent, deci poți proteja un volum important înainte de o operație riscantă. Pentru baze de date de producție se folosesc adesea clase cu reclaimPolicy: Retain.

StatefulSet-urile nu șterg implicit PVC-urile la ștergere sau scalare în jos (persistentVolumeClaimRetentionPolicy cu Retain), tocmai ca protecție. Retain nu înlocuiește însă backup-ul: protejează doar de ștergeri accidentale ale obiectelor, nu de corupere, ștergeri din aplicație sau pierderea zonei.

Ce urmărește intervievatorul: Se verifică riscurile reale de pierdere a datelor. Mulți candidați nu știu că ștergerea PVC-ului șterge implicit și discul.

Eroarea, în practică:PVC blocat în Terminating (pvc-protection)

74 Mid

Ce înseamnă volumeBindingMode: WaitForFirstConsumer și ce problemă rezolvă?

Răspuns scurt: Volumul nu e creat la apariția PVC-ului, ci după ce scheduler-ul alege nodul primului pod care îl folosește, deci discul ajunge în zona acelui nod. Așa eviți podurile blocate pentru că discul a fost creat în altă zonă.

Cu Immediate, PVC-ul declanșează imediat provizionarea. Provisionerul alege o zonă (de exemplu eu-central-1a) fără să știe unde va rula podul. Dacă scheduler-ul vrea apoi să pună podul în eu-central-1b (resurse, afinități, taints), nu poate, pentru că un disc bloc se atașează doar în zona lui. Podul rămâne Pending cu volume node affinity conflict.

Cu WaitForFirstConsumer:

  • PVC-ul rămâne Pending cu evenimentul normal waiting for first consumer to be created before binding;
  • scheduler-ul alege nodul ținând cont de toate constrângerile podului și de topologia disponibilă a stocării;
  • provisionerul creează discul în zona sau pe nodul ales.

Pentru volume locale (local-path, discuri NVMe locale) e obligatoriu, pentru că discul există pe un singur nod.

Capcane: scripturile care așteaptă Bound înainte să creeze podul rămân blocate. Un PVC Pending, fără niciun pod care să-l folosească, e normal în acest mod, nu o eroare. Când podul și PVC-ul tot nu se leagă, problema e la programarea podului: citește întâi evenimentele podului.

Majoritatea claselor implicite moderne (EKS cu EBS CSI, GKE, kind) folosesc deja WaitForFirstConsumer.

Ce urmărește intervievatorul: Intervievatorul verifică înțelegerea legăturii dintre programare și stocare. Mulți interpretează PVC-ul Pending ca eroare.

Eroarea, în practică:WaitForFirstConsumer: waiting for first consumer

75 Mid

Ce se întâmplă cu PVC-urile create de volumeClaimTemplates când scalezi un StatefulSet în jos sau îl ștergi?

Răspuns scurt: Implicit rămân: PVC-urile date-db-2, date-db-1 și datele lor nu sunt șterse, iar la o scalare ulterioară în sus podurile le folosesc din nou. Cu persistentVolumeClaimRetentionPolicy (stabil din 1.32) poți alege Delete la ștergere (whenDeleted) sau la scalare în jos (whenScaled).

Fiecare pod al unui StatefulSet primește un PVC numit ȘABLON-STATEFULSET-INDEX, de exemplu date-db-0. Comportamentul implicit e conservator:

  • la scalarea de la 3 la 1, db-2 și db-1 sunt șterse, dar date-db-2 și date-db-1 rămân;
  • la scalarea înapoi la 3, db-1 se leagă din nou de date-db-1, cu datele vechi (care pot fi depășite pentru o replică de bază de date, iar aplicația trebuie să știe să se resincronizeze);
  • la kubectl delete statefulset db, toate PVC-urile rămân.
YAML
spec:
  persistentVolumeClaimRetentionPolicy:
    whenDeleted: Retain
    whenScaled: Delete

whenScaled: Delete e util pentru clustere de cache sau workeri cu disc temporar, unde datele vechi nu mai au valoare. Pentru baze de date se păstrează de obicei Retain peste tot.

Consecințe practice: PVC-urile rămase costă bani în cloud și trebuie curățate conștient (kubectl delete pvc -l app=db, după ce te asiguri că nu mai sunt necesare). La reinstalarea unui chart Helm cu același nume, StatefulSet-ul nou se leagă de PVC-urile vechi, ceea ce poate surprinde: de exemplu, o parolă nouă de Postgres nu se aplică, pentru că baza de date veche e deja inițializată pe disc.

Ce urmărește intervievatorul: Se verifică experiența cu aplicațiile stateful. Capcana cu parola care nu se schimbă la reinstalare apare des în practică.

Eroarea, în practică:updates to statefulset spec ... are forbidden

76 Mid

Baza de date a rămas fără spațiu pe un PVC de 20Gi. Cum mărești volumul și ce condiții trebuie îndeplinite?

Răspuns scurt: StorageClass-ul trebuie să aibă allowVolumeExpansion: true, iar driverul CSI să suporte expansiunea. Mărești spec.resources.requests.storage pe PVC (doar în sus); driverul extinde discul, apoi sistemul de fișiere e mărit, de obicei online. La StatefulSet-uri modifici direct fiecare PVC, nu volumeClaimTemplates.

Pași:

BASH
kubectl get storageclass ssd -o jsonpath='{.allowVolumeExpansion}'   # true
kubectl patch pvc date-db-0 -p '{"spec":{"resources":{"requests":{"storage":"50Gi"}}}}'
kubectl describe pvc date-db-0   # evenimente: Resizing, FileSystemResizeSuccessful
kubectl get pvc date-db-0        # CAPACITY devine 50Gi

Ce se întâmplă: controllerul de redimensionare cere driverului CSI să mărească discul (de exemplu EBS), apoi kubelet-ul extinde sistemul de fișiere pe nod. Majoritatea driverelor moderne fac totul online, fără repornirea podului; unele cer repornirea podului pentru a doua etapă, iar PVC-ul arată condiția FileSystemResizePending.

Limite:

  • micșorarea nu e posibilă (field can not be less than previous value);
  • clasa fără allowVolumeExpansion refuză cererea; câmpul poate fi activat pe StorageClass, dacă driverul suportă;
  • la un StatefulSet, volumeClaimTemplates sunt imutabile, deci mărești fiecare PVC existent, iar pentru podurile viitoare recreezi StatefulSet-ul cu --cascade=orphan și șablonul nou;
  • unele clouduri limitează frecvența modificărilor aceluiași disc (de exemplu o dată la câteva ore).

Înainte de operație: backup sau snapshot. După: alerte pe gradul de ocupare (kubelet_volume_stats_used_bytes), ca data viitoare să afli înainte să fie plin.

Ce urmărește intervievatorul: Intervievatorul verifică o operație frecventă de producție. Mulți candidați nu știu de limitările StatefulSet-ului.

Eroarea, în practică:PVC: spec is immutable after creation

77 Mid

Cum faci backup pentru datele din volumele persistente și pentru obiectele clusterului?

Răspuns scurt: Pentru volume folosești VolumeSnapshot (prin driverul CSI) sau unelte precum Velero, care salvează și obiectele Kubernetes și volumele; pentru baze de date, backup-uri consistente la nivel de aplicație (pg_dump, WAL archiving). Manifestele stau în git, iar restaurarea se testează periodic.

Trei niveluri:

  • Obiectele clusterului: dacă tot ce livrezi e în git (GitOps), clusterul se poate reconstrui din repository. Rămân obiectele create la rulare (Secret-uri generate, CRD-uri ale operatorilor), pe care Velero le poate salva.
  • Volumele: snapshot-uri prin CSI.
YAML
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshot
metadata: {name: date-db-0-azi}
spec:
  volumeSnapshotClassName: csi-snapclass
  source: {persistentVolumeClaimName: date-db-0}

Restaurarea se face creând un PVC cu dataSource către snapshot. Snapshot-urile sunt rapide, dar rămân de obicei în aceeași regiune și cont, deci nu protejează de orice. Velero automatizează programarea, copierea în object storage și restaurarea pe alt cluster.

  • Aplicația: un snapshot al discului unei baze de date în funcțiune e „crash-consistent”, nu neapărat consistent tranzacțional. Pentru Postgres se preferă backup-uri native (pgBackRest, Barman, WAL archiving cu restaurare la un moment dat), automatizate de operatori precum CloudNativePG.

Ce contează cel mai mult: obiectivele RPO și RTO stabilite cu echipa, backup-urile copiate în altă locație și testele de restaurare periodice. Un backup netestat e doar o speranță.

Ce urmărește intervievatorul: Se verifică maturitatea operațională. Răspunsul slab se oprește la „fac snapshot la disc”.

78 Senior

Ai rula o bază de date de producție în Kubernetes? Cum ai decide?

Răspuns scurt: Depinde de echipă și context. Implicit aleg un serviciu gestionat (RDS, Cloud SQL), care preia backup-ul, failover-ul și upgrade-urile. Kubernetes are sens cu un operator matur, stocare bună și o echipă care știe să-l opereze, pentru portabilitate sau costuri.

Kubernetes poate rula foarte bine baze de date: StatefulSet-uri, volume persistente, PDB-uri, afinități pe zone. Întrebarea reală e cine se ocupă de operații: backup și restaurare la un moment dat, replicare și failover, upgrade de versiune majoră, monitorizare, tuning.

Argumente pentru un serviciu gestionat:

  • operațiile grele sunt automatizate și testate de furnizor;
  • echipa se concentrează pe aplicație;
  • disponibilitatea și backup-urile au garanții contractuale.

Argumente pentru Kubernetes cu operator (CloudNativePG, Zalando Postgres Operator, Percona):

  • același model de livrare și GitOps pentru tot sistemul;
  • portabilitate între clouduri sau on-premise, unde nu există un serviciu gestionat;
  • costuri mai mici la scară sau multe baze de date mici (medii efemere pentru fiecare pull request).

Criteriile pe care le-aș discuta: dimensiunea datelor și cerințele RPO/RTO, experiența echipei cu baze de date, calitatea stocării (latență, snapshot-uri), maturitatea operatorului, cerințele de conformitate și costul total, inclusiv timpul oamenilor.

O cale de mijloc frecventă: baze de date gestionate pentru producție, iar în Kubernetes doar pentru dezvoltare, teste și medii temporare. Indiferent de alegere, regula rămâne: fără StatefulSet scris de mână și fără backup netestat pentru date importante.

Ce urmărește intervievatorul: Intervievatorul evaluează judecata, nu un „da” sau „nu”. Un candidat senior pune întrebări despre echipă și cerințe.

RBAC și securitate

79 Junior

Explică obiectele RBAC: Role, ClusterRole, RoleBinding și ClusterRoleBinding. Când folosești combinația ClusterRole plus RoleBinding?

Răspuns scurt: Role și ClusterRole descriu reguli (verbe pe resurse); RoleBinding și ClusterRoleBinding le dau unor subiecți (utilizatori, grupuri, ServiceAccount-uri). Role și RoleBinding sunt într-un namespace, iar perechea Cluster acționează pe tot clusterul. ClusterRole plus RoleBinding refolosește un rol definit o dată, cu efect doar într-un namespace.

Regulile sunt doar permisive (nu există „deny”): un subiect are drepturile unite din toate legăturile lui.

YAML
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata: {name: cititor-poduri, namespace: echipa}
rules:
- apiGroups: [""]
  resources: [pods, pods/log]
  verbs: [get, list, watch]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata: {name: ana-cititor, namespace: echipa}
subjects:
- {kind: User, name: ana, apiGroup: rbac.authorization.k8s.io}
roleRef: {kind: Role, name: cititor-poduri, apiGroup: rbac.authorization.k8s.io}

Combinațiile:

  • Role + RoleBinding: drepturi într-un namespace;
  • ClusterRole + ClusterRoleBinding: drepturi în tot clusterul, singura variantă pentru resurse fără namespace (nodes, persistentvolumes, namespaces);
  • ClusterRole + RoleBinding: definești o dată rolul (de exemplu rolurile predefinite view, edit, admin) și îl dai în namespace-uri diferite, fiecare cu RoleBinding-ul lui. Așa eviți zeci de copii ale aceluiași Role.

Detalii: apiGroups trebuie să fie corecte (apps pentru deployments, "" pentru pods); subresursele (pods/log, pods/exec, deployments/scale) se cer separat; roleRef nu se poate schimba după creare. Kubernetes nu are obiecte User: utilizatorii vin din certificate, OIDC sau din furnizorul cloud.

Ce urmărește intervievatorul: Se verifică baza autorizării. Combinația ClusterRole cu RoleBinding e adesea necunoscută.

Eroarea, în practică:pods is forbidden: User cannot list resourcenodes is forbidden ... at the cluster scope

80 Junior

Cum verifici ce drepturi are un utilizator sau un ServiceAccount, fără să te autentifici ca el?

Răspuns scurt: Cu kubectl auth can-i VERB RESURSĂ --as=UTILIZATOR (sau --as=system:serviceaccount:NS:NUME) și -n NAMESPACE, iar cu --list vezi toate drepturile din namespace. Îți trebuie dreptul impersonate, de obicei rezervat administratorilor.

BASH
kubectl auth can-i list pods -n echipa --as=ana
kubectl auth can-i delete deployments -n echipa --as=ana
kubectl auth can-i create pods/exec -n prod --as=system:serviceaccount:ci:runner
kubectl auth can-i --list -n echipa --as=ana
kubectl auth can-i '*' '*' --all-namespaces   # ești administrator?
kubectl auth whoami                         # cine sunt (Kubernetes 1.28+)

Răspunsul e yes sau no. --as folosește impersonarea: API server-ul evaluează cererea ca și cum ar veni de la acel subiect. Poți adăuga și grupuri cu --as-group. Dreptul impersonate e puternic (practic poți acționa ca oricine), deci se dă cu grijă.

În practică:

  • după crearea unui Role, verifici imediat atât ce trebuie să meargă, cât și ce nu trebuie (de exemplu că un cititor nu poate șterge);
  • pentru audit, unelte precum kubectl-who-can sau rbac-lookup răspund invers: cine poate face o anumită acțiune;
  • erorile de tip Forbidden spun exact verbul, resursa, grupul API și namespace-ul lipsă, deci le transformi direct în reguli.

Pentru verificări automate în pipeline, testele pot rula kubectl auth can-i și pot eșua dacă un ServiceAccount are mai multe drepturi decât e cazul.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să validezi permisiunile. Greșeala tipică este să dai drepturi prin încercări repetate, fără verificare.

Eroarea, în practică:pods is forbidden: User cannot list resourcecannot patch resource deployments in API group apps

81 Junior

Ce este un ServiceAccount, cum ajunge tokenul în pod și când dezactivezi montarea automată?

Răspuns scurt: ServiceAccount-ul e identitatea podurilor în fața API-ului. Kubelet-ul montează în pod un token proiectat, cu durată limitată și legat de pod, în /var/run/secrets/kubernetes.io/serviceaccount. Dezactivezi montarea (automountServiceAccountToken: false) pentru podurile care nu apelează API-ul Kubernetes.

Fiecare namespace are un ServiceAccount default. Un pod fără serviceAccountName îl folosește. Pentru aplicațiile care vorbesc cu API-ul (operatori, CI, unelte care listează poduri) creezi un ServiceAccount dedicat și îi dai doar drepturile necesare prin RoleBinding.

Tokenul: din Kubernetes 1.22, podurile primesc un token proiectat prin TokenRequest API: JWT cu expirare (implicit o oră, reînnoit automat de kubelet), cu audiență și legat de pod, deci devine invalid după ștergerea podului. Din 1.24 nu se mai creează automat Secret-uri cu tokenuri permanente pentru ServiceAccount-uri.

YAML
apiVersion: v1
kind: ServiceAccount
metadata: {name: web}
automountServiceAccountToken: false
---
spec:
  serviceAccountName: web
  automountServiceAccountToken: false

De ce dezactivezi: dacă o aplicație web e compromisă, atacatorul găsește tokenul în pod și îl poate folosi împotriva API-ului. Fără token (sau cu un ServiceAccount fără drepturi), câștigul e minim.

Alte utilizări: același token, cu altă audiență, poate fi schimbat pe credențiale cloud (IRSA în EKS, Workload Identity în GKE), deci podurile primesc acces la S3 sau la baze de date fără chei statice.

Ce urmărește intervievatorul: Se verifică identitatea podurilor și reducerea suprafeței de atac. Mulți candidați nu știu că tokenurile sunt acum temporare.

Eroarea, în practică:User system:serviceaccount:... cannot listerror looking up service account: not found

82 Junior

Ce setări de securityContext pui implicit pe containerele unei aplicații web și ce face fiecare?

Răspuns scurt: runAsNonRoot: true și un runAsUser fără privilegii, allowPrivilegeEscalation: false, capabilities drop ALL, readOnlyRootFilesystem: true (cu emptyDir pentru folderele în care se scrie) și seccompProfile RuntimeDefault. Împreună limitează ce poate face un atacator care ajunge în container.

YAML
spec:
  securityContext:
    runAsNonRoot: true
    runAsUser: 10001
    fsGroup: 10001
    seccompProfile: {type: RuntimeDefault}
  containers:
  - name: api
    image: academia/api:1.0
    securityContext:
      allowPrivilegeEscalation: false
      readOnlyRootFilesystem: true
      capabilities: {drop: [ALL]}
    volumeMounts:
    - {name: tmp, mountPath: /tmp}
  volumes:
  - name: tmp
    emptyDir: {}
  • runAsNonRoot / runAsUser: procesul nu rulează ca root. Dacă imaginea vrea root, kubelet-ul refuză pornirea (container has runAsNonRoot and image will run as root), deci afli devreme.
  • allowPrivilegeEscalation: false: blochează câștigarea de privilegii prin binare setuid.
  • capabilities drop ALL: scoate capabilitățile Linux (de exemplu NET_RAW); dacă aplicația are nevoie să asculte pe un port sub 1024, adaugi doar NET_BIND_SERVICE sau, mai simplu, folosești un port mare.
  • readOnlyRootFilesystem: un atacator nu poate modifica binarele sau scrie unelte în container; folderele de lucru vin din emptyDir.
  • seccompProfile RuntimeDefault: filtrează apelurile de sistem periculoase.
  • fsGroup: volumele montate primesc grupul potrivit, ca un utilizator non-root să poată scrie.

Aceste setări corespund aproape exact profilului restricted din Pod Security Standards.

Ce urmărește intervievatorul: Intervievatorul verifică practica de securitate pentru containere. Un răspuns bun explică rostul fiecărei setări.

Eroarea, în practică:runAsNonRoot and image will run as root

83 Junior

De ce e preferabil să referi imaginile prin digest sau prin taguri imuabile și cum influențează imagePullPolicy?

Răspuns scurt: Un tag ca latest sau 1.4 se poate muta pe altă imagine, deci poduri diferite pot rula cod diferit, iar rollback-ul devine nesigur. Digest-ul (@sha256:...) fixează conținutul. Cu IfNotPresent, un tag mutat nu e descărcat dacă imaginea există pe nod.

Problemele unui tag mutabil:

  • un pod pornit ieri și unul pornit azi pot rula versiuni diferite cu același tag;
  • rollout undo revine la tagul vechi, dar tagul poate indica deja altceva;
  • un atacator care publică în registry poate înlocui imaginea fără să schimbe manifestul.
YAML
image: registry.academia.ro/magazin/api:1.4.2@sha256:9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08

Cu digest, conținutul e fix. Tagul rămâne pentru oameni, digest-ul pentru mașini.

imagePullPolicy:

  • implicit Always pentru tagul latest sau fără tag, și IfNotPresent pentru restul;
  • IfNotPresent: dacă nodul are deja imaginea cu acel tag, nu o mai descarcă;
  • Always: verifică digest-ul în registry la fiecare pornire (descarcă doar straturile schimbate), dar depinde de disponibilitatea registry-ului;
  • Never: doar imagini deja prezente pe nod.

Practica recomandată: taguri imuabile generate în CI (versiune semantică sau SHA-ul commitului), registry configurat să nu permită suprascrierea tagurilor și, pentru producție, digest-uri fixate de pipeline. Politicile de admitere (Kyverno, Gatekeeper) pot interzice latest și pot cere imagini semnate (cosign) dintr-un registry aprobat.

Ce urmărește intervievatorul: Se verifică reproductibilitatea livrărilor și securitatea lanțului de livrare. Mulți nu știu ce face IfNotPresent cu un tag mutat.

Eroarea, în practică:failed to resolve reference: not found

84 Mid

Ce este Pod Security Admission și cum îl aplici pe un namespace?

Răspuns scurt: E controllerul de admitere integrat (stabil din 1.25) care aplică Pod Security Standards: privileged, baseline și restricted. Îl configurezi prin etichete pe namespace, cu modurile enforce (refuză podurile), audit și warn (doar raportează).

Pod Security Admission a înlocuit PodSecurityPolicy, eliminat în 1.25. Standardele:

  • privileged: fără restricții, pentru componente de sistem (CNI, CSI, agenți de nod);
  • baseline: blochează escaladările cunoscute: privileged: true, hostNetwork, hostPID, hostPath, capabilități periculoase;
  • restricted: în plus cere runAsNonRoot, allowPrivilegeEscalation: false, capabilities drop ALL, seccomp RuntimeDefault și tipuri limitate de volume.
BASH
kubectl label namespace magazin \
  pod-security.kubernetes.io/enforce=baseline \
  pod-security.kubernetes.io/enforce-version=v1.31 \
  pod-security.kubernetes.io/warn=restricted \
  pod-security.kubernetes.io/audit=restricted

Aici podurile care încalcă baseline sunt refuzate, iar pentru restricted primești avertismente la kubectl apply și intrări în audit log. Strategia de adoptare: pornești cu warn și audit pe restricted, repari manifestele, apoi treci enforce la restricted.

Atenție: verificarea se face la crearea podului. Un Deployment e acceptat chiar dacă podurile lui vor fi refuzate, iar eroarea apare în evenimentele ReplicaSet-ului. Pentru reguli mai fine (registry-uri permise, etichete obligatorii, excepții pe aplicații), se adaugă un motor de politici precum Kyverno sau OPA Gatekeeper.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi mecanismul actual, nu PodSecurityPolicy. Mulți nu știu de modurile warn și audit pentru adoptare treptată.

85 Mid

Un coleg propune să dea echipei de dezvoltare dreptul de a crea poduri în producție, „dar fără acces la Secret-uri”. De ce nu e suficient?

Răspuns scurt: Cine creează poduri poate monta și afișa orice Secret din namespace, poate folosi orice ServiceAccount de acolo și, fără Pod Security, poate crea poduri privilegiate care preiau nodul. Dreptul de a crea poduri echivalează aproape cu controlul namespace-ului.

RBAC verifică acțiunea directă, nu ce poate face un pod după ce pornește. Exemple de escaladare:

YAML
spec:
  serviceAccountName: deploy-bot      # orice SA din namespace
  containers:
  - name: x
    image: busybox:1.36
    command: ["sh", "-c", "cat /s/*; sleep 3600"]
    volumeMounts: [{name: s, mountPath: /s}]
  volumes:
  - name: s
    secret: {secretName: db-prod}     # citit fără drept get secrets

Alte verbe și resurse sensibile:

  • pods/exec și pods/attach: intri în containere care au deja secretele în memorie sau în variabile;
  • create pe Deploymenturi, Joburi, CronJob-uri: tot poduri, indirect;
  • escalate și bind pe roluri: îți poți da drepturi pe care nu le ai;
  • impersonate: acționezi ca alt utilizator;
  • update pe nodes sau create pe pods cu hostPath: acces la nod.

Ce propui în schimb: livrare prin pipeline sau GitOps (oamenii nu au drept de scriere în producție), acces de citire (view, care nu include secretele) și loguri, acces de urgență („break glass”) temporar și auditat, Pod Security restricted și ServiceAccount-uri cu drepturi minime în fiecare namespace.

Ce urmărește intervievatorul: Se verifică înțelegerea modelului de amenințare RBAC. Aproape toți candidații subestimează dreptul de a crea poduri.

86 Mid

Găsește problemele de securitate în acest pod.

YAML
apiVersion: v1
kind: Pod
metadata:
  name: monitor
spec:
  hostNetwork: true
  hostPID: true
  containers:
  - name: agent
    image: monitor-agent:latest
    securityContext:
      privileged: true
    env:
    - name: API_KEY
      value: "sk_live_8f2a91c7"
    volumeMounts:
    - name: root
      mountPath: /host
  volumes:
  - name: root
    hostPath:
      path: /

Răspuns scurt: Podul are practic control total asupra nodului: privileged, hostPID, hostNetwork și tot sistemul de fișiere al nodului montat. În plus, cheia API e scrisă în clar în manifest, imaginea folosește latest, iar podul rulează probabil ca root, fără limite de resurse.

Probleme, de la cea mai gravă:

  • privileged: true: containerul are toate capabilitățile și acces la dispozitivele nodului. Ieșirea din container e trivială.
  • hostPath: / montat în /host: tot sistemul de fișiere al nodului, inclusiv cheile kubelet-ului și secretele altor poduri, cu drept de scriere.
  • hostPID: true: vede și poate semnaliza toate procesele nodului; hostNetwork: true: folosește rețeaua nodului, ocolește NetworkPolicy și poate asculta trafic.
  • cheia API în clar: ajunge în git, în kubectl get pod -o yaml și în istoricul shell-ului. Trebuie mutată într-un Secret (ideal dintr-un manager de secrete) și rotită, pentru că e deja expusă.
  • :latest: imagine nefixată, posibil schimbată fără știre.
  • lipsesc resources, runAsNonRoot, readOnlyRootFilesystem, allowPrivilegeEscalation: false.

Versiunea mai sigură pentru un agent de monitorizare: DaemonSet într-un namespace dedicat, imagine fixată prin digest, hostPath doar pentru căile necesare (/proc, /sys, /var/log) montate readOnly: true, capabilități minime (de exemplu doar SYS_PTRACE, dacă e nevoie), cheia din Secret, resurse limitate. Namespace-ul primește un nivel Pod Security potrivit, iar restul clusterului rămâne pe restricted, ca un astfel de pod să nu poată fi creat în namespace-urile aplicațiilor.

Ce urmărește intervievatorul: Intervievatorul verifică dacă recunoști rapid configurațiile periculoase. Un candidat bun le ordonează după gravitate și propune alternativa.

87 Senior

Cum ai organiza un cluster folosit de mai multe echipe, astfel încât să nu se afecteze una pe alta?

Răspuns scurt: Un namespace pe echipă, RBAC prin grupuri, ResourceQuota și LimitRange, NetworkPolicy default-deny, Pod Security restricted, politici de admitere comune și noduri dedicate cu taints unde e nevoie. Pentru clienți care nu au încredere unii în alții, clustere separate.

Multi-tenancy „moale” (echipe din aceeași organizație), pe straturi:

  • Namespace-uri pe echipă și mediu, create din șablon (de exemplu cu un controller sau prin GitOps), cu etichete de proprietar.
  • Identitate și RBAC: grupuri din OIDC (Entra ID, Google, Keycloak), RoleBinding-uri pe ClusterRole-uri standard (view, edit), fără drepturi de cluster pentru echipe.
  • Resurse: ResourceQuota (CPU, memorie, PVC-uri, LoadBalancer-e) și LimitRange cu valori implicite, ca o echipă să nu consume capacitatea celorlalte.
  • Rețea: NetworkPolicy default-deny pe intrare, cu excepții explicite între servicii.
  • Securitate: Pod Security restricted, politici Kyverno sau Gatekeeper (registry-uri permise, fără latest, etichete obligatorii).
  • Prioritate: PriorityClass-uri, ca serviciile critice să nu fie evacuate de joburi de test.
  • Noduri dedicate cu taints și afinități pentru sarcini speciale (GPU, date sensibile).
  • Observabilitate și costuri pe namespace (Prometheus, OpenCost).

Limitele: echipele împart același control plane și kernelul nodurilor. Pentru clienți externi sau date reglementate, aș prefera clustere separate sau clustere virtuale (vcluster), iar alegerea depinde de costuri, de numărul de echipe și de cerințele de conformitate.

Ce urmărește intervievatorul: Se verifică proiectarea platformei la scară. Un candidat senior pomenește și limitele izolării prin namespace.

Eroarea, în practică:exceeded quota: requested, used, limited

88 Senior

Ce sunt admission controllers și webhook-urile de admitere? Cum le folosești pentru politici în cluster?

Răspuns scurt: Interceptează cererile către API după autorizare, înainte de salvare. Cele mutante modifică obiectul (adaugă un sidecar, valori implicite), cele validante îl pot refuza. Webhook-urile aduc logică proprie, iar Kyverno și Gatekeeper le folosesc pentru politici declarative.

Drumul unei cereri: autentificare, autorizare (RBAC), admitere mutantă, validare de schemă, admitere validantă, salvare în etcd. Admission controllers integrați: NamespaceLifecycle, LimitRanger, ResourceQuota, ServiceAccount, PodSecurity.

Webhook-urile (MutatingWebhookConfiguration, ValidatingWebhookConfiguration) trimit obiectul la un serviciu tău, care răspunde cu acceptare, refuz sau patch-uri. Exemple: Istio injectează sidecar-ul, cert-manager validează resursele lui.

Pentru politici, în loc să scrii webhook-uri proprii:

YAML
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata: {name: fara-latest}
spec:
  validationFailureAction: Enforce
  rules:
  - name: tag-fix
    match: {any: [{resources: {kinds: [Pod]}}]}
    validate:
      message: "Tagul latest nu este permis."
      pattern:
        spec:
          containers:
          - image: "!*:latest"

Din 1.30, ValidatingAdmissionPolicy cu expresii CEL e stabil și rulează direct în API server, fără webhook extern.

Riscuri operaționale: un webhook indisponibil cu failurePolicy: Fail poate bloca toate livrările (sau chiar pornirea podurilor de sistem), deci excluzi namespace-urile de sistem, rulezi webhook-ul cu replici multiple și pui timeout-uri mici. Politicile noi se introduc întâi în mod audit.

Ce urmărește intervievatorul: Intervievatorul verifică înțelegerea punctelor de extensie ale API-ului și a riscurilor lor. Puțini candidați pomenesc failurePolicy.

89 Senior

Afli că tokenul unui ServiceAccount cu drepturi largi a ajuns într-un log public. Cum procedezi?

Răspuns scurt: Tratez situația ca incident: invalidez imediat tokenul (șterg Secret-ul cu tokenul permanent sau recreez ServiceAccount-ul), verific în audit log ce s-a făcut cu el, reduc drepturile la minimum, rotesc secretele la care avea acces și documentez cauza ca să nu se repete.

Un răspuns structurat, pe etape:

  • Oprește accesul: dacă e un token permanent (Secret de tip kubernetes.io/service-account-token), șterge Secret-ul și tokenul devine invalid. Pentru tokenuri proiectate (JWT legate de pod), ștergerea podului le invalidează; ștergerea și recrearea ServiceAccount-ului (UID nou) invalidează toate tokenurile emise pentru el. Dacă tokenul era folosit de un sistem extern (CI), îi dai unul nou, cu durată scurtă (kubectl create token --duration).
  • Evaluează impactul: caută în audit log cererile cu user.username egal cu system:serviceaccount:NS:NUME, de la IP-uri necunoscute: ce a citit, ce a creat. Verifică poduri, joburi sau RoleBinding-uri apărute recent.
  • Limitează paguba: rotește secretele pe care tokenul le putea citi (parole de baze de date, chei API), elimină obiectele create de atacator.
  • Repară cauza: de ce a ajuns tokenul în log (un script care afișează variabilele, un mod debug)? Adaugă mascare în CI și scanare de secrete.
  • Prevenție: drepturi minime pentru ServiceAccount-uri, tokenuri cu viață scurtă în loc de Secret-uri permanente, identitate federată (OIDC) pentru CI.

Comunic pe parcurs cu echipa de securitate și scriu un postmortem fără vinovați.

Ce urmărește intervievatorul: Intervievatorul verifică reacția la incidente și cunoașterea tokenurilor. Răspunsul slab se oprește la „șterg tokenul”.

kubectl, Helm și operare

Exersează capitolul cu exerciții reale: Curs Kubernetes online →
90 Junior

Care e diferența dintre kubectl create, kubectl apply și kubectl replace? Ce aduce server-side apply?

Răspuns scurt: create creează obiectul și eșuează dacă există. replace înlocuiește complet obiectul existent cu fișierul. apply e declarativ: creează sau actualizează, făcând o comparație în trei puncte (fișierul, ultima configurație aplicată și obiectul live). Server-side apply mută comparația pe server și ține evidența proprietarului fiecărui câmp.

  • create: imperativ, pentru obiecte noi. Pe un obiect existent dă AlreadyExists.
  • replace: trimite obiectul întreg; câmpurile lipsă din fișier sunt eliminate. Dacă între timp altcineva a schimbat obiectul, cererea poate eșua din cauza resourceVersion sau poate șterge modificări.
  • apply (client-side): salvează fișierul în adnotarea kubectl.kubernetes.io/last-applied-configuration. La următorul apply compară fișierul nou cu adnotarea (ce ai șters tu din fișier e șters) și cu obiectul live (câmpurile adăugate de alții, de exemplu replicas modificat de HPA, rămân dacă nu sunt în fișier).
BASH
kubectl apply -f k8s/
kubectl apply --server-side --field-manager=pipeline -f k8s/
kubectl diff -f k8s/

Server-side apply (stabil din 1.22): serverul ține în metadata.managedFields cine gestionează fiecare câmp. Dacă pipeline-ul încearcă să schimbe un câmp deținut de alt manager (de exemplu HPA-ul), primești un conflict explicit, pe care îl rezolvi cu --force-conflicts sau scoțând câmpul din fișier. Rezolvă și limita de mărime a adnotării last-applied pentru obiecte mari (CRD-uri, ConfigMap-uri mari).

Regula practică: apply din fișiere versionate pentru tot ce e în producție; create doar pentru obiecte ad-hoc sau generate cu --dry-run=client -o yaml.

Ce urmărește intervievatorul: Se verifică diferențele de comportament care cauzează pierderi de modificări. Puțini candidați știu de comparația în trei puncte.

Eroarea, în practică:deployments.apps "web" already exists

91 Junior

Scrie o comandă care afișează, pentru toate podurile din namespace-ul magazin, numele, nodul și imaginea primului container, sortate după numărul de reporniri.

Răspuns scurt: kubectl get pods -n magazin --sort-by='.status.containerStatuses[0].restartCount' -o custom-columns=NUME:.metadata.name,NOD:.spec.nodeName,IMAGINE:.spec.containers[0].image,REPORNIRI:.status.containerStatuses[0].restartCount. Alternativ, -o jsonpath cu range pentru o ieșire prelucrată de alte scripturi.

Cu custom-columns (tabel lizibil):

BASH
kubectl get pods -n magazin \
  --sort-by='.status.containerStatuses[0].restartCount' \
  -o custom-columns='NUME:.metadata.name,NOD:.spec.nodeName,IMAGINE:.spec.containers[0].image,REPORNIRI:.status.containerStatuses[0].restartCount'

Cu jsonpath (pentru scripturi, separat prin tab):

BASH
kubectl get pods -n magazin -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.spec.nodeName}{"\t"}{.spec.containers[0].image}{"\n"}{end}'

Alte forme utile la interviu:

BASH
# toate imaginile distincte din cluster
kubectl get pods -A -o jsonpath='{.items[*].spec.containers[*].image}' | tr ' ' '\n' | sort -u
# podurile care nu rulează
kubectl get pods -A --field-selector=status.phase!=Running
# IP-ul unui pod
kubectl get pod api -o jsonpath='{.status.podIP}'
# filtrare în jsonpath
kubectl get nodes -o jsonpath='{.items[?(@.spec.unschedulable==true)].metadata.name}'

De reținut: --sort-by sortează după valoarea câmpului (numeric sau alfabetic), --field-selector filtrează pe server doar pe câmpuri suportate (status.phase, spec.nodeName, metadata.name), iar pentru prelucrări complexe -o json | jq e adesea mai clar decât jsonpath.

Ce urmărește intervievatorul: Intervievatorul verifică fluența cu kubectl, utilă în orice incident. Mulți candidați știu doar kubectl get simplu.

Eroarea, în practică:error parsing jsonpath, unclosed actionunable to match a printer for the output format

92 Junior

Cum verifici un manifest înainte să-l aplici pe cluster?

Răspuns scurt: kubectl explain pentru câmpurile pe care nu le știi, kubectl apply --dry-run=server pentru validare completă pe server (schemă, admitere, cote) fără salvare, kubectl diff ca să vezi exact ce se schimbă față de obiectul live și, în pipeline, unelte precum kubeconform și kube-linter.

Pași, de la simplu la complet:

  • kubectl explain deployment.spec.strategy.rollingUpdate arată tipul și descrierea fiecărui câmp, pentru versiunea API a clusterului. Cu --recursive vezi tot arborele.
  • kubectl apply --dry-run=client -f app.yaml: verificare locală, superficială (sintaxă, tipuri cunoscute de client).
  • kubectl apply --dry-run=server -f app.yaml: cererea trece prin tot lanțul API server-ului (validare de schemă, câmpuri necunoscute, admission controllers, Pod Security, politici Kyverno), dar nu se salvează. Prinde câmpurile imutabile, selectorii greșiți și refuzurile de politică.
  • kubectl diff -f app.yaml: diff între obiectul live și rezultatul aplicării, cu cod de ieșire 1 dacă există diferențe. Util în pull request-uri sau înaintea unei livrări manuale.
BASH
kubectl diff -f k8s/ && echo "nimic de schimbat"

În pipeline, fără acces la cluster:

  • kubeconform validează manifestele pe schemele versiunii țintă (și pentru CRD-uri);
  • kube-linter sau Polaris semnalează practici proaste: lipsa resurselor, probe lipsă, root;
  • pentru Helm: helm lint și helm template | kubeconform.

Combinația pe care o recomand: validare statică în fiecare pull request și diff plus dry-run=server înaintea livrării.

Ce urmărește intervievatorul: Se verifică disciplina de livrare. Mulți nu știu diferența dintre dry-run client și server.

Eroarea, în practică:strict decoding error: unknown fieldYAML parse error on templates/...

93 Junior

Ce sunt Helm chart, release și values? Cum faci upgrade și rollback cu Helm?

Răspuns scurt: Chartul e un pachet de șabloane parametrizate, release-ul e o instalare a lui într-un namespace, cu istoric de revizii, iar values sunt parametrii (values.yaml, -f, --set). helm upgrade creează o revizie nouă, helm rollback revine la una anterioară.

BASH
helm repo add bitnami https://charts.bitnami.com/bitnami
helm search repo bitnami/redis --versions
helm install cache bitnami/redis --version 20.3.0 -n date --create-namespace -f valori.yaml
helm upgrade cache bitnami/redis --version 20.3.0 -n date -f valori.yaml --set replica.replicaCount=2
helm history cache -n date
helm rollback cache 1 -n date
helm get values cache -n date

Detalii:

  • fiecare revizie e salvată ca Secret sh.helm.release.v1.cache.vN în namespace-ul release-ului;
  • helm upgrade folosește valorile implicite ale chartului plus ce dai acum; valorile date data trecută cu --set se pierd, dacă nu adaugi --reuse-values sau nu folosești mereu același fișier de valori (varianta recomandată);
  • helm upgrade --install e idempotent, potrivit pentru pipeline;
  • --wait --atomic așteaptă ca resursele să fie gata și face rollback automat la eșec;
  • helm template randează local manifestele, util pentru revizuire și pentru GitOps;
  • --version fixează versiunea chartului, diferită de versiunea aplicației.

Rollback-ul Helm revine la manifestele reviziei vechi, dar nu și la datele din volume sau la migrările de bază de date deja rulate. Pentru aplicații cu stare, un rollback trebuie gândit împreună cu schema datelor.

Ce urmărește intervievatorul: Intervievatorul verifică folosirea practică a celui mai răspândit manager de pachete. Capcana cu valorile pierdute la upgrade e frecventă.

Eroarea, în practică:no chart version foundcreate: failed to create: namespaces not found

94 Junior

Ce surse de informație folosești ca să observi o aplicație care rulează în Kubernetes?

Răspuns scurt: Evenimentele și starea obiectelor (kubectl get, describe, events), jurnalele containerelor (kubectl logs, apoi centralizate cu Loki sau Elasticsearch), metricile (metrics-server pentru kubectl top și HPA, Prometheus pentru istoric și alerte) și, pentru sisteme distribuite, trasarea cererilor (OpenTelemetry).

Patru surse, cu rolurile lor:

  • Starea și evenimentele: kubectl get, kubectl describe, kubectl events --for pod/api (sau kubectl get events --sort-by=.lastTimestamp). Evenimentele explică deciziile clusterului (programare, probe, OOM), dar se păstrează doar aproximativ o oră implicit.
  • Jurnalele: aplicația scrie la stdout și stderr, iar runtime-ul le salvează pe nod. kubectl logs le arată doar pentru podurile existente și doar cât se rotesc pe nod. Pentru producție, un agent DaemonSet (Fluent Bit, Vector, Promtail) le trimite într-un sistem central (Loki, Elasticsearch, un serviciu cloud), cu etichete de namespace, pod și aplicație. Jurnalele structurate (JSON) se caută mult mai ușor.
  • Metricile: metrics-server dă consumul curent (kubectl top, HPA), fără istoric. Prometheus colectează metrici de la noduri, kubelet (cAdvisor), kube-state-metrics (starea obiectelor) și aplicații, cu Grafana pentru grafice și Alertmanager pentru alerte.
  • Trasarea: OpenTelemetry și un backend (Jaeger, Tempo) arată drumul unei cereri prin mai multe servicii, util pentru latență.

Alertele bune sunt pe simptome (erori, latență, saturare), nu pe fiecare repornire. Pentru început: reporniri frecvente, poduri ne-Ready, PVC-uri aproape pline, noduri NotReady, erori 5xx.

Ce urmărește intervievatorul: Se verifică viziunea asupra observabilității. Mulți candidați se opresc la kubectl logs.

95 Mid

Când alegi Helm și când Kustomize pentru manifestele unei aplicații?

Răspuns scurt: Helm e un manager de pachete cu șabloane, valori și release-uri, potrivit pentru software distribuit altora. Kustomize modifică YAML simplu prin overlays, fără șabloane, potrivit pentru aplicații proprii cu diferențe mici între medii. Se pot combina.

Helm:

  • șabloane Go cu logică (if, range), deci flexibilitate mare, dar și complexitate și erori de indentare;
  • pachete versionate, publicate în repository-uri sau registre OCI;
  • release-uri cu istoric, upgrade, rollback și hook-uri (de exemplu migrări înainte de upgrade);
  • ideal pentru instalarea software-ului altora (ingress-nginx, Prometheus, Redis) și pentru aplicații interne folosite de multe echipe.

Kustomize:

  • integrat în kubectl apply -k, fără unelte în plus;
  • YAML valid peste tot, fără șabloane; diferențele dintre medii sunt patch-uri explicite;
  • generatoare de ConfigMap-uri și Secret-uri cu hash în nume, transformări de etichete, namespace și imagini;
  • nu are noțiunea de release sau rollback propriu; se bazează pe git și pe unealta de livrare.

Combinații frecvente: chartul unui terț randat cu helm template și ajustat cu Kustomize; Argo CD știe ambele formate. Criteriile mele: cine consumă manifestele (doar echipa sau alții), câte variații există, cât de familiară e echipa cu șabloanele, ce folosește deja platforma. Pentru o aplicație internă cu trei medii, Kustomize e de obicei suficient și mai ușor de citit într-un pull request.

Ce urmărește intervievatorul: Intervievatorul verifică judecata în alegerea uneltelor. Răspunsul slab declară una dintre ele „mai bună” fără context.

Eroarea, în practică:must specify one of -f and -kcannot be imported: invalid ownership metadata

96 Mid

Trebuie să faci mentenanță pe un nod de producție. Ce comenzi rulezi și ce poate bloca procesul?

Răspuns scurt: kubectl cordon (nodul nu mai primește poduri), kubectl drain --ignore-daemonsets --delete-emptydir-data (podurile sunt evacuate respectând PDB-urile), mentenanța, apoi kubectl uncordon. Drain-ul poate fi blocat de PDB-uri prea stricte, poduri fără controller, poduri cu emptyDir sau perioade de grație foarte lungi.

BASH
kubectl cordon worker-2
kubectl drain worker-2 --ignore-daemonsets --delete-emptydir-data --timeout=10m
# mentenanță: actualizare de kernel, repornire, înlocuire disc
kubectl uncordon worker-2

Ce face drain-ul: marchează nodul SchedulingDisabled, apoi cere evacuarea fiecărui pod prin Eviction API. Controllerele creează poduri înlocuitoare pe alte noduri.

Blocaje frecvente și ce înseamnă:

  • cannot delete DaemonSet-managed Pods: adaugi --ignore-daemonsets (podurile DaemonSet rămân, sunt legate de nod);
  • cannot delete Pods with local storage: podurile cu emptyDir își pierd datele temporare; confirmi cu --delete-emptydir-data;
  • cannot delete Pods declare no controller: poduri simple, care nu ar fi recreate; --force le șterge definitiv, deci verifici întâi ce sunt;
  • Cannot evict pod as it would violate the pod's disruption budget: drain-ul reîncearcă; dacă PDB-ul cere toate replicile disponibile sau aplicația are o singură replică, rămâne blocat până intervii.

Înainte: verific că restul nodurilor au capacitate pentru podurile mutate, că aplicațiile critice au mai multe replici și PDB-uri rezonabile. După uncordon, podurile nu se întorc automat; nodul primește doar poduri noi.

Ce urmărește intervievatorul: Se verifică o procedură operațională de bază. Un candidat bun explică fiecare blocaj, nu doar comenzile.

Eroarea, în practică:node(s) were unschedulablecannot delete DaemonSet-managed Pods

97 Mid

Cum planifici upgrade-ul unui cluster Kubernetes la o versiune minoră nouă?

Răspuns scurt: Citesc notele versiunii și API-urile eliminate, verific manifestele cu pluto sau kubent, testez întâi pe staging, actualizez control plane-ul câte o versiune minoră, apoi nodurile prin rotație cu drain, plus addon-urile compatibile.

Pași pentru un upgrade de la 1.30 la 1.31:

  • Pregătire: citești changelog-ul și secțiunea de deprecieri. API-urile eliminate sunt cea mai frecventă cauză de probleme (exemple istorice: extensions/v1beta1 Ingress în 1.22, PodSecurityPolicy în 1.25). Verifici manifestele, charturile și resursele live cu unelte precum pluto sau kubent și cu metrica apiserver_requested_deprecated_apis.
  • Compatibilitatea addon-urilor: CNI, CSI, ingress controller, cert-manager, operatorii și versiunea kubectl din pipeline trebuie să suporte noua versiune.
  • Ordinea: control plane-ul întâi, câte o versiune minoră o dată (nu sari de la 1.29 la 1.31). Kubelet-ul poate fi cu până la trei versiuni minore în urma API server-ului (din 1.28), deci nodurile se actualizează după control plane.
  • Nodurile: rotație: nod nou cu versiunea nouă sau upgrade pe loc, cordon și drain pe nodul vechi, cu PDB-uri care permit evacuarea.
  • Testare: același proces întâi în staging, cu testele aplicațiilor, apoi în producție, cu un plan de rollback (în clusterele gestionate, rollback-ul control plane-ului de obicei nu e posibil, deci testarea contează).
  • După: verifici podurile, evenimentele și metricile, apoi actualizezi kubectl și documentația.

Cadența contează: versiunile minore apar aproximativ la patru luni și au suport limitat, iar un cluster rămas mult în urmă devine o migrare dificilă.

Ce urmărește intervievatorul: Intervievatorul verifică experiența cu ciclul de viață al clusterului. Greșeala tipică este să ignori API-urile eliminate.

Eroarea, în practică:no matches for kind "Deployment" in version

98 Senior

Imediat după un rollout în producție, rata de erori 5xx crește de la 0,1% la 4%. Ce faci, pas cu pas?

Răspuns scurt: Întâi stabilizez: dacă erorile coincid cu rollout-ul, fac rollback (kubectl rollout undo sau revert în git) fără să aștept diagnosticul. Apoi confirm revenirea în metrici, comunic, investighez cauza într-un mediu sigur și închid cu un postmortem.

Un model de răspuns structurat:

  • Confirmare rapidă (1-2 minute): erorile au crescut exact la livrare? Vin doar de la podurile noi? kubectl rollout status, metricile de erori pe versiune (etichete pe pod) și jurnalele podurilor noi.
  • Stabilizare: dacă legătura e probabilă, rollback imediat. Diagnosticul vine după ce utilizatorii nu mai sunt afectați.
BASH
kubectl rollout undo deployment/plati -n prod
kubectl rollout status deployment/plati -n prod

Cu GitOps, fac revert la commit, altfel sincronizarea readuce versiunea stricată. Dacă rollout-ul încă rula, kubectl rollout pause oprește extinderea.

  • Comunicare: anunț pe canalul de incidente ce s-a întâmplat, ce am făcut și când revin cu informații.
  • Verificare: rata de erori revine la normal? Dacă nu, problema nu era versiunea (dependență externă, configurare schimbată în paralel) și continui investigația.
  • Cauza: reproduc în staging, compar configurația, citesc jurnalele salvate, verific migrările de date (un rollback de cod după o migrare incompatibilă poate fi el însuși periculos).
  • Prevenție: postmortem fără vinovați și măsuri concrete: readiness mai bun, canary cu analiză automată, teste care ar fi prins problema, alertă pe erori pe versiune.

Ce urmărește intervievatorul: Intervievatorul evaluează calmul și prioritățile în incident. Răspunsul slab începe cu ore de depanare în timp ce utilizatorii primesc erori.

Eroarea, în practică:deployment exceeded its progress deadline

99 Senior

Un dezvoltator din echipă îți spune că „Kubernetes îi omoară aplicația” (OOMKilled de mai multe ori pe zi) și îți cere să scoți limita de memorie. Cum discuți cu el?

Răspuns scurt: Explic ce înseamnă OOMKilled (aplicația a depășit limita stabilită), măsurăm împreună consumul real, ajustăm limita pe baza datelor sau reparăm consumul și explic de ce fără limită problema se mută pe nod, unde afectează și alte aplicații.

Un model de răspuns:

  • Ascult și reformulez: aplicația e repornită de mai multe ori pe zi, utilizatorii sunt afectați, iar el vrea o soluție rapidă. Recunosc că problema e reală.
  • Explic mecanismul fără jargon: limita de memorie e un plafon; când procesul îl depășește, kernelul îl oprește, iar Kubernetes îl repornește. Fără limită, aplicația ar putea consuma memoria nodului, iar atunci ar fi evacuate și alte poduri, inclusiv ale altor echipe.
  • Ne uităm împreună la date: graficul de memorie al podului (Prometheus, kubectl top) înaintea fiecărui OOM. Crește constant (scurgere), are vârfuri la anumite cereri (de exemplu exporturi mari) sau e aproape de limită de la pornire (limita e pur și simplu prea mică)?
  • Soluții după caz: pentru JVM, verificăm că heap-ul e dimensionat față de limită (-XX:MaxRAMPercentage), nu fix; pentru vârfuri, procesare în bucăți sau streaming; pentru scurgeri, un profil de memorie; dacă nevoia e reală, mărim limita și requests, documentat.
  • Închidere: punem o alertă care avertizează înainte de OOM și notăm decizia.

Ideea centrală: rezolvăm cauza cu date, nu eliminăm o protecție. Tonul e de colaborare, nu de „regulile platformei”.

Ce urmărește intervievatorul: Se verifică comunicarea tehnică și capacitatea de a educa fără a impune. Un candidat bun propune o investigație comună.

Eroarea, în practică:OOMKilled (Exit Code 137)

100 Senior

Ți se cere să pregătești livrarea unei aplicații noi (API plus bază de date) pe clusterul companiei. Ce ar conține lista ta de verificare înainte de producție?

Răspuns scurt: Imagine fixată și scanată, minim 2 replici, requests și limite, probe, oprire grațioasă, PDB, Ingress cu TLS, secrete separate, ServiceAccount minim, securityContext restrictiv, NetworkPolicy, observabilitate, backup și livrare prin pipeline cu rollback testat.

O listă pe categorii, pe care aș parcurge-o cu echipa:

  • Imagine: tag imuabil sau digest, utilizator non-root, scanare de vulnerabilități în CI.
  • Workload: Deployment cu minim 2 replici, resources măsurate, readiness, liveness și (dacă pornește greu) startup probe, tratarea SIGTERM și preStop, topologySpreadConstraints, PDB, HPA dacă încărcarea variază.
  • Rețea: Service cu porturi numite, Ingress cu TLS (cert-manager), timeout-uri și limite de mărime a cererilor, NetworkPolicy care permite doar traficul necesar spre baza de date.
  • Configurare: ConfigMap pentru setări, Secret din managerul de secrete (External Secrets), nicio parolă în git, configurații pe medii prin Kustomize sau Helm.
  • Securitate: ServiceAccount dedicat fără token montat (dacă nu e nevoie), securityContext restrictiv, namespace cu Pod Security restricted.
  • Date: bază de date gestionată sau operator, backup cu restaurare testată, migrări de schemă compatibile cu rollback-ul.
  • Observabilitate: jurnale structurate centralizate, metrici și panou, alerte pe erori, latență și saturare, runbook pentru incidente.
  • Livrare: pipeline sau GitOps, rollout status cu rollback automat, mediu de staging identic ca structură, test de încărcare.

La final, o revizie cu echipa de operare și o fereastră de lansare cu cineva pregătit să intervină.

Ce urmărește intervievatorul: Intervievatorul verifică dacă vezi întregul tablou al unei livrări de producție. Un candidat senior prioritizează și explică de ce contează fiecare punct.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Kubernetes, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Kubernetes scriind cod, nu doar citind

Curs Kubernetes: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 12 lecții sunt gratuite.